# Daft.ie Property Scraper: Ireland Sale & Rent Listings (`cprussin/daft-ie-property`) Actor

Scrape Daft.ie property for sale and to rent in Ireland by area, price and bedrooms: price, beds, baths, type, floor area, BER, address, county, Eircode, coordinates, agency and agent. No login. $2.50 per 1,000 listings, +$1.50 per 1,000 with details.

- **URL**: https://apify.com/cprussin/daft-ie-property.md
- **Developed by:** [Connor Prussin](https://apify.com/cprussin) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Daft.ie Property Scraper: Ireland Sale & Rent Listings

**Daft.ie Property Scraper** exports property listings from Daft.ie, Ireland's largest property site, as clean JSON, CSV or Excel. It reads the same public search and listing pages the site shows, with no login and no API key:

- ✅ **For sale and to rent**, by county, city, town or Dublin district, or the whole of Ireland.
- ✅ **Filters**: price range and bedrooms, or paste any Daft.ie search URL with its own filters.
- ✅ **Price** as a number in euro (plus the original text and the rent period), bedrooms, bathrooms, property type, floor area.
- ✅ **BER** energy rating and EPI.
- ✅ **Location**: address, county, Eircode, latitude and longitude.
- ✅ **Agency contacts**: agency, agent name, phone and PSRA licence. Private sellers' names and phone numbers are never output.
- ✅ **Listing details (optional)**: full description, features, first-published date, views and all photos.
- ✅ Deduplicated across pages and searches; fast plain HTTP requests, no browser. Pay only for listings written to your dataset.

### Start in one minute

Click **Start** with the prefilled input:

```json
{
  "areas": ["dublin"],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

You get: 20 Dublin properties for sale with `price`, `bedrooms`, `bathrooms`, `propertyType`, `floorArea`, `berRating`, `address`, `agency` and `url`.

**Cost:** $0.05: 20 listings × $0.0025, plus the $0.00005 actor-start fee.

### Use with an AI assistant

Connect the [Apify MCP server](https://mcp.apify.com) to Claude, ChatGPT, Cursor or any MCP client (`https://mcp.apify.com?tools=cprussin/daft-ie-property` loads only this actor), then paste:

```text
Use the Apify actor cprussin/daft-ie-property to find 50 two-bedroom rentals in Cork under €2,000 a month, and list price, address, BER and agency.
```

### Recipes

#### Rentals under a budget

Two-bed-plus rentals in Cork up to €2,000 a month.

```json
{
  "areas": ["cork"],
  "searchType": "rent",
  "maxPrice": 2000,
  "minBeds": 2,
  "maxItems": 100
}
```

#### Houses for sale with full details

Galway homes between €300k and €500k, with descriptions and all photos.

```json
{
  "areas": ["galway"],
  "minPrice": 300000,
  "maxPrice": 500000,
  "includeDetails": true,
  "maxItems": 50
}
```

#### Estate agent lead list

Every listing in a county, for agency names, phones and PSRA licences.

```json
{
  "areas": ["kildare"],
  "maxItems": 1000
}
```

### Who uses Daft.ie data?

- **Investors and buyers**: track asking prices, price per m² and BER across areas.
- **Estate agents and mortgage brokers**: monitor new listings and competitor agencies.
- **Lettings and relocation**: compare rents by area and property type.
- **Analysts and journalists**: study Ireland's housing supply and rents.
- **AI agents**: give an LLM live Irish property listings through the Apify API or MCP server.

### How does the Daft.ie scraper work?

1. It checks daft.ie/robots.txt and only fetches allowed URLs (never `/api`, `sort_by`, `offset` or `from_search` pages).
2. It loads the search page, e.g. `daft.ie/property-for-sale/dublin`, and reads the listing data embedded in it (20 per page).
3. It follows `?page=2`, `?page=3`, ... until `maxItems` listings.
4. With **Include listing details** on, it also opens each listing page.

### How do I choose which properties to scrape?

| Field                   | Description                                         | Example                                                 |
| ----------------------- | --------------------------------------------------- | ------------------------------------------------------- |
| `areas`                 | Daft.ie area slugs                                  | `["dublin", "cork-city"]`                               |
| `searchType`            | `sale` or `rent`                                    | `"rent"`                                                |
| `startUrls`             | Daft.ie search or listing pages                     | `["https://www.daft.ie/property-for-rent/cork/houses"]` |
| `minPrice` / `maxPrice` | Price (sale) or monthly rent (rent) range in euro   | `300000` / `500000`                                     |
| `minBeds` / `maxBeds`   | Bedroom range                                       | `2` / `4`                                               |
| `maxItems`              | Max listings in total                               | `500`                                                   |
| `includeDetails`        | Open each listing page for description and features | `true`                                                  |
| `proxyConfiguration`    | Apify Proxy (on by default; datacenter is enough)   | `{ "useApifyProxy": true }`                             |

- **Area slugs** are what you see in Daft.ie URLs: `daft.ie/property-for-sale/`**`shankill-dublin`**.

### What data do you get for each property?

```json
{
  "id": "6678479",
  "title": "The Old Station Master's House, Dublin Road, Shankill, Dublin 18, D18 Y6Y8",
  "url": "https://www.daft.ie/for-sale/the-old-station-masters-house-dublin-road-shankill-dublin-18/6678479",
  "searchType": "sale",
  "price": 1475000,
  "priceText": "€1,475,000",
  "pricePeriod": null,
  "currency": "EUR",
  "bedrooms": 6,
  "bathrooms": 5,
  "propertyType": "Detached",
  "floorArea": 433,
  "floorAreaUnit": "m2",
  "berRating": "SI_666",
  "berEpi": "143.66 kWh/m2/yr",
  "address": "The Old Station Master's House, Dublin Road, Shankill, Dublin 18",
  "county": "Dublin",
  "eircode": "D18 Y6Y8",
  "latitude": 53.233707,
  "longitude": -6.124625,
  "sellerType": "BRANDED_AGENT",
  "agency": "Lisney Sotheby's International Realty (Dalkey)",
  "agentName": "Rory Kirwan",
  "agentPhone": "01 285 1005",
  "agentLicence": "001848",
  "facilities": ["Parking"],
  "publishedAt": "2026-10-29T11:53:41.874Z",
  "imageUrl": "https://media.daft.ie/eyJidWNrZXQiOi...",
  "imageCount": 32,
  "searchUrl": "https://www.daft.ie/property-for-sale/dublin",
  "scrapedAt": "2026-10-29T15:00:00.000Z"
}
```

With **Include listing details** you also get `description`, `features`, `firstPublishedAt`, `views` and `images`.

### How much does it cost to scrape Daft.ie?

Pay per event:

- **$0.0025 per listing** ($2.50 per 1,000).
- **$0.0015 per listing with details** ($1.50 per 1,000 extra), only when **Include listing details** is on or for listing URLs.
- $0.00005 per run start. Platform compute is included.

### FAQ

**Why are some agent fields empty?** Private sellers' names and phone numbers are never output; contact them through Daft.ie.

**What does BER SI_666 mean?** The property is exempt from BER (e.g. a protected structure).

**Is it legal?** The actor reads public listing pages that robots.txt allows, without login, and outputs agency contacts only. Check Daft.ie's terms for your use case.

### Related actors

- [Google Trends](https://apify.com/cprussin/google-trends): search interest over time, e.g. for areas or property types.
- [New Business Registrations](https://apify.com/cprussin/new-business-registrations): newly registered companies for lead lists.

# Actor input Schema

## `areas` (type: `array`):

Daft.ie area slugs, as in daft.ie/property-for-sale/<b>dublin</b>: a county (<code>dublin</code>, <code>cork</code>, <code>galway</code>), a city (<code>cork-city</code>) or a town/district (<code>shankill-dublin</code>, <code>dublin-8-dublin</code>). Use <code>ireland</code> for the whole country.

## `searchType` (type: `string`):

Residential property for sale or to rent.

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

Optional Daft.ie search pages with their own filters, e.g. <code>https://www.daft.ie/property-for-rent/cork/houses?rentalPrice_to=2000</code>, or listing pages, e.g. <code>https://www.daft.ie/for-sale/some-address/6678479</code>. The filters below don't apply to start URLs.

## `minPrice` (type: `integer`):

Minimum asking price (sale) or monthly rent (rent).

## `maxPrice` (type: `integer`):

Maximum asking price (sale) or monthly rent (rent).

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

Minimum number of bedrooms.

## `maxBeds` (type: `integer`):

Maximum number of bedrooms.

## `maxItems` (type: `integer`):

Stop after this many listings in total, across all searches. Each listing is billed as one listing.

## `includeDetails` (type: `boolean`):

Open each listing page for the full description, feature list, first-published date, view count and all photos (one extra request and one listing-details event per listing). Off: search data only, which already has price, rooms, type, floor area, BER, address, coordinates and agency.

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

Apify Proxy (datacenter is enough). The actor switches to a new IP whenever a request is blocked or fails, and falls back to direct requests if the proxy keeps failing.

## Actor input object example

```json
{
  "areas": [
    "dublin"
  ],
  "searchType": "sale",
  "maxItems": 20,
  "includeDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "areas": [
        "dublin"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cprussin/daft-ie-property").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 = {
    "areas": ["dublin"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "areas": [
    "dublin"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call cprussin/daft-ie-property --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cprussin/daft-ie-property"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/mRRx2wc2ocBAnbQpx/builds/G34loICZMjWhGwWyV/openapi.json