# Funda Property Extractor (`kawsar/funda-property-extractor`) Actor

Funda property extractor that collects Dutch housing listings from funda.nl, so anyone tracking prices, comparing neighborhoods, or researching the Netherlands real estate market gets structured data fast.

- **URL**: https://apify.com/kawsar/funda-property-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Real estate, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.99 / 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

## Funda Property Extractor

Extract structured property listings from funda.nl, the largest real estate marketplace in the Netherlands. Paste one or more funda.nl search URLs and the actor delivers clean, structured data for every listing — addresses, prices, living areas, energy labels, neighborhoods, agent details, and photos — for both sale and rental properties across all Dutch cities.

Pagination is handled automatically. No browser required. No manual copying.

---

### What data does this actor extract?

Each listing returns up to 24 structured fields. Fields that carry no data for a given listing are omitted from the output, keeping your dataset clean.

| Field | Type | Description |
|---|---|---|
| `listingId` | string | Funda internal object ID |
| `url` | string | Full URL to the listing detail page |
| `address` | string | Street name and house number |
| `postalCode` | string | Dutch postal code, e.g. `1091 GH` |
| `city` | string | City name |
| `neighborhood` | string | Neighborhood or district within the city |
| `price` | integer | Asking price in euros |
| `priceText` | string | Price as displayed on funda.nl, e.g. `€ 425.000 k.k.` |
| `priceCondition` | string | `k.k.` (buyer pays transfer costs) or `v.o.n.` (seller pays) |
| `livingArea` | integer | Interior living space in m² |
| `plotArea` | integer | Plot or land area in m² (houses only) |
| `rooms` | integer | Total number of rooms |
| `bedrooms` | integer | Number of bedrooms |
| `propertyKind` | string | Property category, e.g. `Appartement`, `Tussenwoning`, `Hoekwoning` |
| `energyLabel` | string | Energy certificate: `A`, `A+`, `B`, `C`, `D`, `E`, `F`, or `G` |
| `listingDate` | string | ISO 8601 date the listing was first published |
| `mainImageUrl` | string | Primary listing photo URL |
| `imageUrls` | array | All photo URLs for the listing |
| `agentName` | string | Real estate agent or broker name |
| `agentUrl` | string | Agent profile page URL on funda.nl |
| `status` | string | `te koop` (for sale) or `te huur` (for rent) |
| `transactionType` | string | `koop` (sale) or `huur` (rental) |
| `shortDescription` | string | Featured listing teaser text, where available |
| `scrapedAt` | string | ISO 8601 timestamp of when this record was collected |

---

### How to use

#### Step 1 — Copy a search URL from funda.nl

1. Open [funda.nl](https://www.funda.nl) in your browser
2. Use the search bar and filters to narrow down listings (city, price range, property type, area, etc.)
3. Copy the full URL from the address bar

Examples:
````

https://www.funda.nl/zoeken/koop/?selected\_area=%5B%22amsterdam%22%5D
https://www.funda.nl/zoeken/huur/?selected\_area=%5B%22rotterdam%22%5D\&price\_max=2000
https://www.funda.nl/zoeken/koop/?selected\_area=%5B%22utrecht%22%5D\&floor\_area\_min=80\&price\_max=500000

````

#### Step 2 — Paste into the actor input

Open the actor input form and paste your URL(s) into the **Search URLs** field. You can add multiple URLs to scrape several cities or filter sets in a single run. Each URL is processed independently and the `maxItems` limit applies per URL.

#### Step 3 — Run and export

Click **Start** and the actor will paginate through results automatically. When the run finishes, export your dataset as JSON, CSV, Excel, or JSONL from the **Storage** tab.

---

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchUrls` | array | | One or more funda.nl search URLs to scrape |
| `maxItems` | integer | `15` | Maximum listings to collect **per URL**, up to 1000 |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout in seconds (5–120) |

---

### Example output

```json
{
  "listingId": "44454713",
  "url": "https://www.funda.nl/detail/koop/amsterdam/appartement-eerste-atjehstraat-152-c/44454713/",
  "address": "Eerste Atjehstraat 152-C",
  "postalCode": "1094 KW",
  "city": "Amsterdam",
  "neighborhood": "Timorpleinbuurt-Zuid",
  "price": 475000,
  "priceText": "€ 475.000 k.k.",
  "priceCondition": "k.k.",
  "livingArea": 50,
  "rooms": 2,
  "bedrooms": 1,
  "propertyKind": "Appartement",
  "energyLabel": "C",
  "listingDate": "2026-05-21",
  "mainImageUrl": "https://cloud.funda.nl/tiara-media/e8bc9f2a-ba85-4bd9-879a-279142b455e7/d0114dff-0c33-42c6-a50a-afb66845c1af?options=width=720",
  "imageUrls": [
    "https://cloud.funda.nl/tiara-media/e8bc9f2a-ba85-4bd9-879a-279142b455e7/d0114dff-0c33-42c6-a50a-afb66845c1af?options=width=720",
    "https://cloud.funda.nl/tiara-media/e8bc9f2a-ba85-4bd9-879a-279142b455e7/27533cfd-16d1-423e-97ef-e0e04a87eaa6?options=width=464"
  ],
  "agentName": "Hellema Makelaars",
  "agentUrl": "https://www.funda.nl/makelaar/5098-hellema-makelaars/",
  "status": "te koop",
  "transactionType": "koop",
  "shortDescription": "Stijlvol en instapklaar wonen op een toplocatie in Amsterdam!",
  "scrapedAt": "2026-05-21T14:30:00+00:00"
}
````

***

### Use cases

**Price tracking and market analysis**
Monitor asking prices across Amsterdam, Rotterdam, Utrecht, Den Haag, or any Dutch city. Run the actor on a schedule to build a time-series dataset and spot trends in specific neighborhoods or property types.

**Investment research**
Filter by energy label, living area, and price range to identify properties that match your investment criteria. Export to Excel or connect to a BI tool to compare yields across different areas.

**Rental market monitoring**
Track rental price movements and availability in target neighborhoods. Use the `huur` transaction type to pull rental listings and monitor supply week over week.

**Multi-city comparison**
Supply multiple search URLs in one run — one per city or filter set — to compare markets side by side in a single dataset.

**Property portfolio tools**
Feed listing data into your own platform, CRM, or alerting system. The structured JSON output integrates with any workflow using Apify's built-in webhooks and integrations.

**Academic and journalistic research**
Collect large samples of Dutch housing market data for statistical analysis, reporting, or visualization projects.

***

### Pagination and limits

The actor follows funda.nl pagination automatically. Each search results page returns 15 listings. The actor continues fetching pages until it reaches `maxItems` for that URL or there are no more results.

The `maxItems` limit applies **per URL**. If you supply three search URLs with `maxItems` set to 100, the actor will collect up to 100 listings from each URL, for a potential total of 300. The maximum value per URL is 1000.

***

### Output format

Results are written to the default Apify dataset and can be exported in:

- **JSON** — one object per listing, full field set
- **CSV** — flat table, one row per listing
- **Excel (XLSX)** — same as CSV, formatted for spreadsheet tools
- **JSONL** — newline-delimited JSON for streaming or big-data pipelines
- **XML** — for legacy integrations

Fields with no data for a given listing are omitted from the record rather than returned as `null`.

***

### FAQ

**Can this actor scrape both sale and rental listings?**
Yes. Paste a `zoeken/koop/` URL for sale listings or a `zoeken/huur/` URL for rentals. You can mix both in the same run by adding URLs of each type to `searchUrls`.

**Does it paginate automatically?**
Yes. The actor fetches every page of results for each URL until it reaches your `maxItems` limit or runs out of listings.

**What is `maxItems` — total or per URL?**
Per URL. If you supply two URLs and set `maxItems` to 50, the actor collects up to 50 listings from each URL.

**Can I scrape multiple cities or filter sets at once?**
Yes. Add one URL per city or filter combination to the `searchUrls` field. All URLs are processed in sequence within a single run.

**How do I build a filtered search URL?**
Apply your filters on funda.nl (city, price range, living area, property type, energy label, etc.) and copy the URL from the address bar. The URL encodes all your selected filters automatically.

**What does k.k. mean?**
`k.k.` is kosten koper — the buyer pays transfer tax and notary fees on top of the listed price. `v.o.n.` is vrij op naam — those costs are covered by the seller. The `priceCondition` field records whichever applies.

**Are new-build properties included?**
Yes. Filter by new-build on funda.nl (`nieuwbouw` in the object type filter) and paste that URL into the actor.

**How fresh is the data?**
The actor reads the live funda.nl website at the time of each run, so data reflects what is currently listed. Run the actor on a schedule to keep your dataset current.

**What happens if a field has no data?**
Fields with no value for a specific listing are omitted from that record entirely. You will never see `null` values in the output.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more funda.nl search URLs to scrape. Each URL is processed separately with full pagination.

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

Maximum number of property listings to extract per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.funda.nl/zoeken/koop/?selected_area=%5B%22amsterdam%22%5D"
  ],
  "maxItems": 15,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "searchUrls": [
        "https://www.funda.nl/zoeken/koop/?selected_area=%5B%22amsterdam%22%5D"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/funda-property-extractor").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 = { "searchUrls": ["https://www.funda.nl/zoeken/koop/?selected_area=%5B%22amsterdam%22%5D"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/funda-property-extractor").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 '{
  "searchUrls": [
    "https://www.funda.nl/zoeken/koop/?selected_area=%5B%22amsterdam%22%5D"
  ]
}' |
apify call kawsar/funda-property-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Funda Property Extractor",
        "description": "Funda property extractor that collects Dutch housing listings from funda.nl, so anyone tracking prices, comparing neighborhoods, or researching the Netherlands real estate market gets structured data fast.",
        "version": "0.0",
        "x-build-id": "dgrgCRIiE0Q8bztn0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~funda-property-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-funda-property-extractor",
                "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/kawsar~funda-property-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-funda-property-extractor",
                "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/kawsar~funda-property-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-funda-property-extractor",
                "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": {
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "One or more funda.nl search URLs to scrape. Each URL is processed separately with full pagination.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of property listings to extract per run.",
                        "default": 15
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
