# Daft.ie Scraper | Irish Property Listings + Agents (`haketa/daft-scraper`) Actor

Daft.ie scraper & API for Ireland real estate: search property for sale, rent and sharing and export address, price, beds, baths, BER energy, Eircode, type, agent, photos and coordinates. Ireland property market data and real-estate lead generation — fast, no login.

- **URL**: https://apify.com/haketa/daft-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 10 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Daft.ie Scraper | Irish Property Listings with BER, Geo & Agent Data

The fastest way to pull every listing on **Daft.ie** — Ireland's biggest property portal — into a clean structured dataset. Per property you get the price, beds, type, **BER energy rating**, geo coordinates, **Eircode**, full description, features and the listing agent's profile. Covers **for-sale**, **for-rent**, **sharing (rooms)**, **new-homes** and **commercial** sections across every Irish county.

No browser. No login. No API key. The actor reads each search and detail page's Next.js `__NEXT_DATA__` state directly, so the data is structured, complete and matches exactly what daft.ie renders.

> **TL;DR** — Pick a section + location ("property-for-sale" + "dublin-city"), pick a `maxRecords` cap, run. Every row is one property with everything joined: price, beds, BER, lat/lon, agent.

***

### What you get

For each property, one row with:

| Field | What |
| --- | --- |
| `propertyId` | Numeric Daft.ie listing id (stable) |
| `daftShortcode` | Daft's own short code (shown on the card) |
| `title` | Full title / address line as Daft.ie publishes it |
| `category` | "Buy" / "Rent" / "Share" / "Commercial" |
| `propertyType` | Apartment / House / Studio / Site / … |
| `priceRaw` | Original price string ("€450,000" or "From €710 per month") |
| `priceMin`, `priceMax` | Numeric values (€). For range prices both are set; for single prices `min == max` |
| `priceCurrency` | "EUR" (or "GBP" for the rare cross-border listing) |
| `pricePeriod` | "month" / "week" / "year" / null (sale) |
| `numBedrooms` | Raw label ("3 Bed", "1, 2 & 3 bed", "Studio") |
| `numBedroomsMin`, `numBedroomsMax` | Parsed integer min/max |
| `numBathrooms` | Bath count |
| **`berRating`** | Irish Building Energy Rating (`A1`, `A2`, `A3`, `B1`, … `G`, `EXEMPT`) |
| `floorArea` | "120 m²" string when published |
| `dateOfConstruction` | Year built |
| `address` | The full title address |
| **`eircode`** | Irish postcode (`D02 RK57`, `T12 HD21`, …) mined from title + URL |
| `city` | Parsed city / area |
| `county` | Parsed Irish county |
| `country` | "Ireland" |
| `latitude`, `longitude` | Geo coordinates from Daft's Point GeoJSON |
| `featuredLevel` | FEATURED / etc. (premium tier on the search page) |
| `publishDate`, `firstPublishDate`, `lastUpdateDate` | ISO dates |
| `description` | Full description (when `scrapeDescription: true`) |
| `features` | Array of bullet features (when `scrapeDescription: true`) |
| **`agentName`**, `agentBranch`, `agentType`, `agentLicenceNumber`, `agentLogoUrl` | Listing agent profile |
| `premierPartner`, `showContactForm` | Daft.ie agent-tier flags |
| `imageUrl`, `images`, `imageCount` | First image + up to 12 gallery URLs |
| `subUnitCount` | When the listing is an apartment-complex parent, how many sub-units it has |
| `listingUrl` | Canonical Daft.ie detail URL |
| `searchSection`, `searchLocation`, `searchUrl` | Echo of the search you ran |
| `scrapedAt` | ISO timestamp |

The complete schema with types is in `dataset_schema.json`.

***

### Why these fields matter

**BER (Building Energy Rating)** — Ireland's mandatory energy label. Buyers and renters increasingly filter on it; investors track it for value-add deal flow ("buy F-rated, retrofit to B2, resell"). No other property data source surfaces it as a structured column.

**Eircode** — Ireland's seven-character postcode. Every Eircode pinpoints to a single building, making it perfect for joining with census, demographic and electricity-use datasets.

**Latitude / longitude** — pulled straight from Daft's own Point geometry. Drop the dataset into Mapbox / Tableau / Looker for instant heat-maps.

**Agent profile** — the `agentId`, `agentName`, `agentBranch`, `agentLicenceNumber` plus `premierPartner` flag let you build a competitive map of who lists what in which area. Estate agencies use this to monitor competitors; PropTech vendors use it for sales pipeline.

**`featuredLevel` / `premierPartner`** — Daft.ie's premium ad tier signal. Useful for marketers and agencies to size the paid-ad budget of the market.

***

### Use cases

#### Real-estate agencies (competitive intel)

- Snapshot the entire `dublin-city` `property-for-sale` market daily — track which agents are getting new instructions, what's selling, what's lingering.
- Build a heat-map of new listings per area to time outreach to landlords.

#### PropTech / data analytics

- BER-rated rental yield analysis — pair `priceMin` with `floorArea` for €/m² and stratify by `berRating` for a real-time energy-vs-price index.
- Affordability dashboards — pull all of Ireland by county weekly, model median asking price by bedroom count.

#### Mortgage / lending teams

- Pre-approval intelligence — surface fresh listings in your target customer's price band the moment they're posted.

#### International buyers (US / UK)

- Save hours of manual browsing — filter Daft via this actor for your exact `priceFrom`/`priceTo`/`minBeds` and pipe to Notion, Sheets or your buyer's CRM.

#### Estate-agent SaaS / CRM vendors

- Map every active agent in Ireland (`agentName` + `agentBranch` + `agentLicenceNumber`) — the single best B2B prospecting list for selling to estate agents.

#### Investment funds / institutional rental

- Track the new-build BTR pipeline in real time via the `new-homes-for-sale` section + the `prs.subUnits` count we surface.

#### Compliance / market research

- Run the same query weekly and dataset-diff to compute time-on-market, price reductions and supply by area.

***

### Inputs (full list)

Definitions live in `input_schema.json`; here's the human summary.

- **`section`** *(select)* — `property-for-sale` (default), `property-for-rent`, `sharing`, `new-homes-for-sale`, `commercial-properties-for-sale`, `commercial-properties-for-rent`.
- **`location`** *(string)* — Daft.ie location slug. Examples: `dublin-city`, `cork`, `galway`, `limerick`, `kildare`, `wicklow`, `dun-laoghaire-rathdown`. Leave empty for all-Ireland.
- **`startUrls`** *(array)* — Paste Daft.ie search URLs directly. Overrides section / location / filters.
- **`priceFrom`, `priceTo`** *(integer)* — Optional price band (€). For rent these are per-month.
- **`minBeds`** *(integer)* — Minimum bedroom count.
- **`scrapeDescription`** *(boolean)* — Visit each detail page for full description + features + last-update date. The base listing already carries title, price, beds, BER, geo, agent — disable detail visit for 5× faster runs.
- **`maxRecords`** *(integer)* — Hard cap on properties returned. Default `100`.
- **`maxPages`** *(integer)* — Hard cap on pagination. `0` = unlimited (bounded by `maxRecords`).
- **`requestDelay`** *(integer)* — Milliseconds between page fetches. Default `1000`.
- **`proxyConfiguration`** *(proxy)* — Apify Proxy. Defaults to RESIDENTIAL + country IE — datacenter triggers Daft.ie's "Security Check" interstitial within a few requests.

***

### Example inputs

#### 1. Dublin sale listings, default cap

```json
{
  "section": "property-for-sale",
  "location": "dublin-city",
  "maxRecords": 100
}
```

#### 2. Cork rentals under €2,000/month, ≥2 beds, fast list-only

```json
{
  "section": "property-for-rent",
  "location": "cork",
  "priceTo": 2000,
  "minBeds": 2,
  "scrapeDescription": false,
  "maxRecords": 250
}
```

#### 3. Galway room-shares with full descriptions

```json
{
  "section": "sharing",
  "location": "galway-city",
  "scrapeDescription": true,
  "maxRecords": 60
}
```

#### 4. Direct Daft.ie URL paste

```json
{
  "startUrls": [
    { "url": "https://www.daft.ie/property-for-sale/dublin-city-centre?price=300000-500000&numBeds_from=2" }
  ],
  "maxRecords": 300
}
```

#### 5. All-Ireland new-homes pipeline (deep crawl)

```json
{
  "section": "new-homes-for-sale",
  "location": "ireland",
  "scrapeDescription": true,
  "maxRecords": 1000,
  "maxPages": 60,
  "requestDelay": 1500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "IE"
  }
}
```

***

### Output sample

```json
{
  "propertyId": "6561825",
  "daftShortcode": "96561825",
  "title": "Baile Adaim, Carrigtwohill, Co. Cork",
  "category": "Rent",
  "propertyType": "Private Rental Sector",
  "priceRaw": "From €710 per month",
  "priceMin": 710,
  "priceMax": 710,
  "priceCurrency": "EUR",
  "pricePeriod": "month",
  "numBedrooms": "1, 2 & 3 bed",
  "numBedroomsMin": 1,
  "numBedroomsMax": 3,
  "numBathrooms": null,
  "berRating": "A2",
  "floorArea": null,
  "dateOfConstruction": null,
  "address": "Baile Adaim, Carrigtwohill, Co. Cork",
  "eircode": null,
  "city": "Baile Adaim",
  "county": "Cork",
  "country": "Ireland",
  "latitude": 51.91742,
  "longitude": -8.24198,
  "featuredLevel": "FEATURED",
  "publishDate": "2026-05-05",
  "firstPublishDate": null,
  "lastUpdateDate": null,
  "agentId": "13053",
  "agentName": "Paul Barry",
  "agentBranch": "Cork County Council",
  "agentType": "UNBRANDED_AGENT",
  "agentLicenceNumber": "Cork County Council",
  "agentLogoUrl": "https://media.daft.ie/…",
  "premierPartner": false,
  "showContactForm": true,
  "imageUrl": "https://media.daft.ie/…",
  "imageCount": 8,
  "subUnitCount": 3,
  "listingUrl": "https://www.daft.ie/for-rent/baile-adaim-carrigtwohill-co-cork-…/6561825",
  "searchSection": "property-for-rent",
  "searchLocation": "cork",
  "scrapedAt": "2026-05-31T18:57:13.000Z"
}
```

***

### Cost & throughput

Pay-per-event pricing — small `apify-actor-start` fee plus a per-result charge. The exact tier is on the actor's Apify Store page.

Default throughput (`scrapeDescription: false`, `requestDelay: 1000`):

- \~20 listings per page × ~1.5 s per page = **~13 listings / second**.
- 1,000 listings ≈ 80 seconds.
- With `scrapeDescription: true` add ~1 s/listing for the detail fetch.

Daft.ie caps pagination at ~167 pages × 20 listings = ~3,300 results per query. To go deeper, split by county, then by city / area, then by price band.

***

### How it works (under the hood)

1. **Search URL build** — `https://www.daft.ie/{section}/{location}?page=N&priceFrom=…&numBeds_from=…`.
2. **`__NEXT_DATA__` parse** — Daft.ie ships its entire React state inside `<script id="__NEXT_DATA__">`. We pull `props.pageProps.listings` (per-page array of 20 properties), `props.pageProps.paging` (current page, total pages, total results) and `props.pageProps.queryFilters`.
3. **Field mapping** — listing.title → title, listing.price → priceRaw + parsed `priceMin`/`priceMax`/`priceCurrency`/`pricePeriod`, listing.ber.rating → berRating, listing.point.coordinates → lat/lon, listing.seller → agent fields, listing.seoFriendlyPath → listingUrl.
4. **Eircode mining** — Irish postcode regex (`[ADEFHKNPRTVWXY]\d{2} [A-Z0-9]{4}`) over title + URL slug + description.
5. **Detail enrichment** *(optional)* — for each listing, fetch the detail URL and pull the longer `description`, `features` array and `lastUpdateDate` from its own `__NEXT_DATA__` block.
6. **Dedup** — by numeric `propertyId`. The same listing surfacing on overlapping pages is only emitted once.
7. **Backoff** — retries on 403 / 429 / "Security Check" interstitial with a fresh proxy session per attempt.

Built on `got-scraping` + `cheerio` — no Puppeteer, no Playwright, runs in 512 MB.

***

### Tips & troubleshooting

**Q: I'm getting `No properties scraped — Daft.ie blocked the discovery page`.**
A: Almost certainly the proxy group is wrong. Daft.ie shows a "Security Check" challenge to datacenter IPs within a few requests; switch the proxy group to `RESIDENTIAL` and set country to `IE`. UK / US residential IPs sometimes also trigger the check — IE residential is the most reliable.

**Q: My run says `No properties matched your filters`.**
A: Your filter is too narrow. Drop `priceTo`, lower `minBeds`, broaden the `location` to the county slug (e.g. `cork` instead of `cork-city-centre`).

**Q: Why is `berRating` null on so many rentals?**
A: Landlords aren't legally required to publish BER on every rental ad until certified. The actor reads what Daft.ie publishes — when the rating is missing on the source page, the field stays null. (Sale listings carry BER far more reliably.)

**Q: `eircode` is empty most of the time.**
A: Eircode is included in the title / URL slug only when the seller chose to publish it. Set `scrapeDescription: true` and we also mine the full description text — that recovers Eircode for an additional ~15-20% of listings.

**Q: I want sub-units inside apartment-complex listings as separate rows.**
A: The parent listing's `subUnitCount` flags how many sub-units it has. v1 emits one row per parent listing with the sub-units summary; ping the Store page if you want a `mode: per-subUnit` flag added.

**Q: Why does pagination stop earlier than the total pages count?**
A: Daft.ie caps deep pagination around page 167 (~3,300 results) regardless of true total. To go further, split the query (e.g. by `priceFrom`/`priceTo` bands).

**Q: How fresh is the data?**
A: Real-time. Each run pulls Daft.ie's live `__NEXT_DATA__`; there is no cache layer in the actor.

**Q: Can I scrape just one specific listing?**
A: Yes — drop the listing's detail URL into `startUrls`. The actor recognises detail URLs and emits one row.

**Q: Can I run this on a schedule?**
A: Yes — Apify Schedules picks it up natively. Daily / hourly cron is fine; lower `maxRecords` to keep cost predictable.

***

### How this compares

There's exactly one other Daft.ie scraper on the Apify Store (about 350 runs / month). Here's how this one positions:

- **Multi-section** — sale, rent, sharing, new-homes, commercial sale, commercial rent. The competitor covers sale + rent only.
- **BER rating + Eircode + geo lat/lon** as structured columns — the high-signal Irish-specific fields the alternative doesn't surface.
- **Agent profile in every row** — `agentId`, `agentName`, `agentBranch`, `agentLicenceNumber`. Build the agent-leads list for free as a side-effect of every property run.
- **Cloudflare / "Security Check" handling** baked in — proxy prefill is RESIDENTIAL + IE because that's what survives Daft.ie's anti-bot for sustained runs.
- **Healthy run semantics** — empty filter results exit `SUCCEEDED` with an actionable status message rather than `FAILED`.

***

### Legal & ethical use

This actor reads public, indexable Daft.ie HTML — the same pages Google sees. Use responsibly:

- Republishing the data as a competing portal infringes Daft.ie's Terms; build derived products (analytics, dashboards, alerts) instead.
- Contacting agents en-masse without an established business relationship needs a lawful basis under the GDPR (legitimate interest works for B2B if the topic is relevant and you respect opt-outs).
- The actor never bypasses logins, paywalls or `robots.txt`-disallowed paths.

***

### Pricing-tier playbooks (when you graduate from one-off runs)

If you're scheduling Daft.ie runs daily / weekly for a real workflow, these are the patterns that survive at scale:

1. **County-by-county sweep.** Don't try to grab "all of Ireland" in one run — Daft.ie caps pagination ~3,300 results. Run one search per county (`dublin-city`, `cork`, `galway`, `limerick`, `kildare`, `wicklow`, `meath`, `donegal`, …) and union the datasets. Daily refresh keeps cost in the cents.
2. **Price-band shards.** For Dublin sale (`> 3,300` results) split by price: `<300k`, `300-500k`, `500-750k`, `750k-1m`, `>1m`. Five small runs cover the full market without hitting the pagination cap.
3. **Delta scheduling.** Run the same query once a day and dedup by `propertyId` against your warehouse's previous snapshot — new rows = new listings, missing rows = sold / withdrawn. Tracks time-on-market for free.
4. **Agent prospecting.** Run a single sale-and-rent sweep per county per week; dedup the result by `agentId` and you've built a refreshed agent list ideal for B2B SaaS targeting Irish estate agents.

### Frequently-asked filters

- **`location`** — Irish county slugs use the official Daft.ie slug. The most common ones: `dublin-city`, `dublin-county`, `dun-laoghaire-rathdown`, `fingal`, `south-dublin`, `cork-city`, `cork-county`, `galway-city`, `galway-county`, `limerick-city`, `kerry`, `kildare`, `meath`, `wicklow`, `wexford`, `donegal`, `mayo`, `clare`, `tipperary`, `waterford-city`. For all-Ireland leave empty or use `ireland`.
- **Direct URL paste** — every Daft.ie search-results page works as a `startUrls` value. Toggle filters in your browser, copy the URL once you're happy, paste in.
- **`numBeds_from`** — Daft.ie's own URL parameter; the actor passes it through when you set `minBeds`. Use `startUrls` for the more exotic combinations (`numBeds_to`, `dateOfConstruction_from`, etc.).

***

### Changelog

**Last updated:** 2026-07-02 — Actor verified and maintained. Data pipeline tested for quality, structure and freshness; selectors/endpoints confirmed against the live site.

- **2026-07-02** — Maintenance pass: verified `__NEXT_DATA__` selectors, BER/Eircode/geo/agent extraction and detail enrichment against live Daft.ie; confirmed data quality, structure and freshness.
- **1.0** — Initial release. Sections: property-for-sale, property-for-rent, sharing, new-homes-for-sale, commercial sale & rent. `__NEXT_DATA__` parser, BER + Eircode + geo + agent extraction. Detail-page enrichment for description + features.

***

### Roadmap / feature requests

- `mode: per-subUnit` for apartment-complex parents.
- Historical price-change tracking (compare across runs).
- Agent-list-only mode (one row per `agentId`, with summary stats).
- Map-bounding-box search input (lat/lon polygon → Daft search URL).
- Saved-search delta mode (emit only listings new vs the previous run).

Drop a comment on the Store page if any of these would unblock you.

# Actor input Schema

## `section` (type: `string`):

Which part of the Daft.ie market to pull — sale, rent, sharing, new homes or commercial.

## `location` (type: `string`):

Choose a county or city. Pick 'All Ireland' to scan the whole country. Need a specific town or Dublin postal district not listed here? Use the 'Custom location' box below.

## `locationCustom` (type: `string`):

Optional. Type an exact Daft.ie area slug for a town or district not in the dropdown, e.g. 'dublin-2-dublin', 'blackrock-cork', 'maynooth-kildare'. When filled, this overrides the Location dropdown above.

## `startUrls` (type: `array`):

Optional. Paste ready-made Daft.ie search URLs (e.g. 'https://www.daft.ie/property-for-sale/cork-city?price=300000-500000\&numBeds\_from=3'). When provided, these override the section, location and filters above.

## `priceFrom` (type: `integer`):

Optional minimum price. For rent searches, this is per month. 0 = no minimum.

## `priceTo` (type: `integer`):

Optional maximum price. For rent searches, this is per month. 0 = no maximum.

## `minBeds` (type: `integer`):

Only return listings with at least this many bedrooms. 0 = no filter.

## `scrapeDescription` (type: `boolean`):

Visit each property's detail page to pull the full description, feature list and last-update date. Leave off for fast list-only scraping — most data (price, beds, BER, geo coords, agent) is already on the search page.

## `maxRecords` (type: `integer`):

Cap on total properties returned. Set 0 for unlimited. Each search page has 20 listings and Daft.ie caps at ~167 pages (~3,300 results) per query.

## `maxPages` (type: `integer`):

Cap on listing pages walked per search. 0 = unlimited (bounded by Max Records).

## `requestDelay` (type: `integer`):

Delay between page requests. 800–1500 ms keeps the run smooth and reliable.

## `proxyConfiguration` (type: `object`):

Runs with RESIDENTIAL Irish IPs by default for the most reliable results. Keep this on for best coverage.

## Actor input object example

```json
{
  "section": "property-for-sale",
  "location": "dublin",
  "startUrls": [],
  "priceFrom": 0,
  "priceTo": 0,
  "minBeds": 0,
  "scrapeDescription": false,
  "maxRecords": 100,
  "maxPages": 0,
  "requestDelay": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All extracted Daft.ie property records for this run.

## `overviewTable` (type: `string`):

A clean, human-readable table of the scraped properties.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "section": "property-for-sale",
    "location": "dublin",
    "locationCustom": "",
    "startUrls": [],
    "scrapeDescription": false,
    "maxRecords": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/daft-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "section": "property-for-sale",
    "location": "dublin",
    "locationCustom": "",
    "startUrls": [],
    "scrapeDescription": False,
    "maxRecords": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/daft-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "section": "property-for-sale",
  "location": "dublin",
  "locationCustom": "",
  "startUrls": [],
  "scrapeDescription": false,
  "maxRecords": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IE"
  }
}' |
apify call haketa/daft-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=haketa/daft-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/f9Imo61OungN8uIEF/builds/Z3qBx5f4yvmLlElkw/openapi.json