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

Scrape Daft.ie — Ireland's biggest property portal. Per-listing price, beds, type, BER energy rating, geo coordinates, full description, features, agent profile and Eircode. Supports sale, rent, sharing, commercial and new-homes searches across Dublin, Cork, Galway, Limerick and every county.

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

## Pricing

from $0.70 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

- **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 Daft.ie section to crawl.

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

County, city or area slug. Examples: 'dublin-city', 'cork', 'galway', 'limerick', 'kildare', 'wicklow'. Leave empty for all-Ireland.

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

Paste Daft.ie search URLs directly (e.g. 'https://www.daft.ie/property-for-sale/cork-city?price=300000-500000\&numBeds\_from=3'). When provided, overrides section / location / filters.

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

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

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

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

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

Filter to 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. Disable for fast list-only scraping (most data — price, beds, BER, geo coords, agent — is already on the search page).

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

Hard 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`):

Hard cap on listing pages walked per search. 0 = unlimited (bounded by maxRecords).

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

Delay between page requests. 800–1500 ms keeps the run friendly to Daft.ie's anti-bot.

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

ON by default with RESIDENTIAL + country IE — datacenter proxy gets challenged with 'Security Check' very quickly on Daft.ie, residential rotates through real Irish IPs and reliably bypasses it.

## Actor input object example

```json
{
  "section": "property-for-sale",
  "location": "dublin-city",
  "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

## `propertyId` (type: `string`):

Numeric Daft listing id

## `title` (type: `string`):

Property title / address line

## `category` (type: `string`):

Sale / Rent / Share / Commercial

## `propertyType` (type: `string`):

Apartment, House, Studio, …

## `priceRaw` (type: `string`):

Human-readable price

## `priceMin` (type: `string`):

Numeric minimum price

## `numBedrooms` (type: `string`):

Bedroom count or range

## `berRating` (type: `string`):

Irish energy rating (A1–G)

## `city` (type: `string`):

City / area

## `county` (type: `string`):

Irish county

## `agentName` (type: `string`):

Listing agent / estate agency

## `publishDate` (type: `string`):

ISO publish date

## `listingUrl` (type: `string`):

Daft.ie listing URL

## `scrapedAt` (type: `string`):

ISO timestamp

# 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-city",
    "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-city",
    "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-city",
  "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

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Daft.ie Scraper | Irish Property Listings + Agents",
        "description": "Scrape Daft.ie — Ireland's biggest property portal. Per-listing price, beds, type, BER energy rating, geo coordinates, full description, features, agent profile and Eircode. Supports sale, rent, sharing, commercial and new-homes searches across Dublin, Cork, Galway, Limerick and every county.",
        "version": "1.0",
        "x-build-id": "h66IDStbIjnXsg4Q5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~daft-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-daft-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/haketa~daft-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-daft-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/haketa~daft-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-daft-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "section": {
                        "title": "Section",
                        "enum": [
                            "property-for-sale",
                            "property-for-rent",
                            "sharing",
                            "new-homes-for-sale",
                            "commercial-properties-for-sale",
                            "commercial-properties-for-rent"
                        ],
                        "type": "string",
                        "description": "Which Daft.ie section to crawl.",
                        "default": "property-for-sale"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "County, city or area slug. Examples: 'dublin-city', 'cork', 'galway', 'limerick', 'kildare', 'wicklow'. Leave empty for all-Ireland."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste Daft.ie search URLs directly (e.g. 'https://www.daft.ie/property-for-sale/cork-city?price=300000-500000&numBeds_from=3'). When provided, overrides section / location / filters.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "priceFrom": {
                        "title": "Price From (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum price. For rent searches, this is per month.",
                        "default": 0
                    },
                    "priceTo": {
                        "title": "Price To (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional maximum price. For rent searches, this is per month.",
                        "default": 0
                    },
                    "minBeds": {
                        "title": "Minimum Bedrooms",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter to listings with at least this many bedrooms (0 = no filter).",
                        "default": 0
                    },
                    "scrapeDescription": {
                        "title": "Scrape Full Description (per-listing detail)",
                        "type": "boolean",
                        "description": "Visit each property's detail page to pull the full description, feature list and last-update date. Disable for fast list-only scraping (most data — price, beds, BER, geo coords, agent — is already on the search page).",
                        "default": false
                    },
                    "maxRecords": {
                        "title": "Max Records",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard 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.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on listing pages walked per search. 0 = unlimited (bounded by maxRecords).",
                        "default": 0
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 300,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between page requests. 800–1500 ms keeps the run friendly to Daft.ie's anti-bot.",
                        "default": 1000
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "ON by default with RESIDENTIAL + country IE — datacenter proxy gets challenged with 'Security Check' very quickly on Daft.ie, residential rotates through real Irish IPs and reliably bypasses it."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```