# Funda Netherlands Real Estate Scraper (`datascrapers/funda-nl-scraper`) Actor

Scrape property listings from Funda.nl — the largest real estate platform in the Netherlands. Supports buy and rent, all property types, price ranges, locations, and detailed filters.

- **URL**: https://apify.com/datascrapers/funda-nl-scraper.md
- **Developed by:** [Farhan Ali](https://apify.com/datascrapers) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

**Funda Netherlands Real Estate Scraper** creates a structured dataset of property listings collected from [Funda.nl](https://www.funda.nl), the largest real estate platform in the Netherlands. Each dataset item represents one property and can include address, price, size, energy label, rooms, and agent details, with optional full descriptions, coordinates, photo galleries, and agent contact information. Query the source by Funda search URL or by location with detailed filters, control the result limit with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, or other supported formats.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | funda.nl (Netherlands) |
| Record unit | One property listing, with optional nested detail and agent-contact fields |
| Input methods | Funda search URL (`startUrls`) or location search (`searchQueries`) with filters |
| Main identifiers | `listingId`, listing `url` |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, HTML (Apify dataset exports) |
| Update model | Fresh records per Actor run |
| Pricing | $1 per 1,000 listings; +$1 per 1,000 for details; +$1 per 1,000 for agent contact |

### Coverage and available records

The Actor collects properties from public Funda pages using one of two entry points:

- **URL-based**: Pass full Funda search result URLs in `startUrls`. Parameters are read from the URL; any filter missing from the URL is taken from the input fields below it.
- **Location-based**: Pass city names, neighborhoods, or postal codes (for example `Amsterdam` or `1012AB`) in `searchQueries`, combined with `offeringType` and filters. URLs without a location search nationwide.

Supported property types: `apartment`, `house`, `parking`, `berth`, `pitch`, `land`, `storage`, `storage_space`, and `substructure`.

Record types and limits:

- **Listing-level records** are always collected: address, price, price value, price condition, offering type, property type, construction type, floor area, rooms, bedrooms, energy label, description, coordinates, and agent name.
- **Detail fields** are conditional: the full listing description, property features, coordinates, and complete photo gallery are returned when `extractDetails` is enabled.
- **Agent contact fields** are conditional: phone number, contact person name, and office details are returned when `extractAgentContact` is enabled.
- **Result cap**: `maxItems` limits the number of listings collected (`0` means no limit; the default is `100`).

Known exclusions: each run captures page state at run time (no historical snapshots); detail and agent-contact fields are not collected unless their toggles are enabled.

### Data dictionary

Field names below match dataset record JSON properties exactly. Fields marked *conditional* appear only when the corresponding input toggle is enabled.

| Field | Type | Nullable | Description | Example |
|---|---:|---|---|---|
| `address` | string | No | Full address string | `Wilhelminastraat 117 3, 1054WB Amsterdam` |
| `streetName` | string | Yes | Street name | `Wilhelminastraat` |
| `houseNumber` | string | Yes | House number | `117` |
| `postalCode` | string | Yes | Dutch postal code | `1054WB` |
| `city` | string | Yes | City | `Amsterdam` |
| `neighbourhood` | string | Yes | Neighborhood | `Cremerbuurt-West` |
| `municipality` | string | Yes | Municipality | `Amsterdam` |
| `province` | string | Yes | Province | `Noord-Holland` |
| `price` | string | Yes | Price as rendered (with condition) | `€975.000 k.k.` |
| `priceValue` | number | Yes | Numeric price in EUR | `975000` |
| `priceCondition` | string | Yes | Price condition | `kosten_koper` |
| `offeringType` | string | Yes | Buy or rent | `buy` |
| `propertyType` | string | Yes | Property type | `apartment` |
| `constructionType` | string | Yes | Construction type | `resale` |
| `floorArea` | number | Yes | Floor area in m² | `110` |
| `rooms` | number | Yes | Number of rooms | `4` |
| `bedrooms` | number | Yes | Number of bedrooms | `3` |
| `energyLabel` | string | Yes | Energy label (A++++ to G) | `B` |
| `description` | string | Yes | Short promo description | `Dubbel bovenhuis met dakterras...` |
| `agentName` | string | Yes | Listing agent name | `Living Real Estate` |
| `agentPhone` | string | Yes | Agent phone (conditional — `extractAgentContact`) | `0205287862` |
| `agentContactName` | string | Yes | Contact person (conditional — `extractAgentContact`) | `Angelique Bijleveld` |
| `latitude` | number | Yes | Map latitude (conditional — `extractDetails`) | `52.36126` |
| `longitude` | number | Yes | Map longitude (conditional — `extractDetails`) | `4.862332` |
| `url` | string | Yes | Listing detail URL | `https://www.funda.nl/detail/koop/amsterdam/...` |
| `listingId` | number | No | Funda listing identifier; best stable deduplication key | `8054903` |
| `publicationDate` | string | Yes | Publication timestamp (ISO 8601) | `2026-06-21T09:00:02.7905094+02:00` |
| `status` | string | Yes | Listing status | `none` |
| `images` | string\[] | Yes | Photo gallery URLs (conditional — `extractDetails`) | `["https://cloud.funda.nl/...", ...]` |

### Example dataset record

Real record produced with a location search (`searchQueries: ["Amsterdam"]`), buy offering, details and agent contact enabled. The `images` array is truncated for readability.

```json
{
  "address": "Wilhelminastraat 117 3, 1054WB Amsterdam",
  "streetName": "Wilhelminastraat",
  "houseNumber": "117",
  "postalCode": "1054WB",
  "city": "Amsterdam",
  "neighbourhood": "Cremerbuurt-West",
  "municipality": "Amsterdam",
  "province": "Noord-Holland",
  "price": "€975.000 k.k.",
  "priceValue": 975000,
  "priceCondition": "kosten_koper",
  "offeringType": "buy",
  "propertyType": "apartment",
  "constructionType": "resale",
  "floorArea": 110,
  "rooms": 4,
  "bedrooms": 3,
  "energyLabel": "B",
  "description": "Dubbel bovenhuis met dakterras op toplocatie, eigen grond en 3 slpkmr",
  "agentName": "Living Real Estate",
  "agentPhone": "0205287862",
  "agentContactName": "Angelique Bijleveld",
  "latitude": 52.36126,
  "longitude": 4.862332,
  "url": "https://www.funda.nl/detail/koop/amsterdam/appartement-wilhelminastraat-117-3/44409366/",
  "listingId": 8054903,
  "publicationDate": "2026-06-21T09:00:02.7905094+02:00",
  "status": "none",
  "images": ["https://cloud.funda.nl/valentina_media/b9028258-c909-48d7-b7eb-a77d10135299/14cb40c3-a40f-4e8d-ae1b-e66956f7c18d"]
}
```

The record above was produced with this input:

```json
{
  "searchQueries": ["Amsterdam"],
  "offeringType": "buy",
  "minPrice": 150000,
  "maxPrice": 750000,
  "propertyTypes": ["apartment", "house"],
  "extractDetails": true,
  "extractAgentContact": true,
  "maxItems": 50,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---|---|---|---|
| `startUrls` | array (requestListSources) | No\* | prefill URL | Funda search result URLs | URL-based entry point; parameters are read from the URL |
| `searchQueries` | array (stringList) | No\* | `["Amsterdam"]` | City names, neighborhoods, postal codes | Location search, ignored when URLs are provided |
| `offeringType` | string | No | `buy` | `buy`, `rent` | Buy (koop) or rent (huur) |
| `minPrice` | integer | No | — | `0` or positive integer | Minimum asking price in EUR |
| `maxPrice` | integer | No | — | `0` or positive integer | Maximum asking price in EUR |
| `propertyTypes` | array | No | `["apartment", "house"]` | `apartment`, `house`, `parking`, `berth`, `pitch`, `land`, `storage`, `storage_space`, `substructure` | Property types; empty means all |
| `constructionType` | string | No | `""` | `""`, `resale`, `newly_built` | Construction type filter |
| `minFloorArea` / `maxFloorArea` | integer | No | — | `0` or positive integer | Living area range in m² |
| `minPlotArea` / `maxPlotArea` | integer | No | — | `0` or positive integer | Plot area range in m² |
| `minRooms` / `maxRooms` | integer | No | — | `0` or positive integer | Room count range |
| `minBedrooms` / `maxBedrooms` | integer | No | — | `0` or positive integer | Bedroom count range |
| `publicationDate` | string | No | `no_preference` | `no_preference`, `1`, `3`, `7`, `10`, `14`, `30` | Listings published within N days |
| `availability` | string | No | `available` | `available`, `negotiations`, `available_and_negotiations`, `sold` | Availability status |
| `energyLabels` | array | No | `[]` | `A++++` … `G` | Energy label filter; empty means all |
| `exteriorSpaceTypes` | array | No | `[]` | `garden`, `balcony`, `terrace` | Exterior space filter |
| `hasGarden` | boolean | No | `false` | `true` / `false` | Shortcut for exterior space garden |
| `constructionPeriods` | array | No | `[]` | `before_1906` … `after_2020` | Construction period filter |
| `surroundingTypes` | array | No | `[]` | `rural`, `in_center`, `by_water`, and more | Surrounding area filter |
| `garage*` / `parking*` | boolean | No | `false` | `true` / `false` | Garage and parking filters |
| `freeTextSearch` | string | No | — | Free text | Search within listing descriptions |
| `sortBy` | string | No | `relevance` | `relevance`, `price_asc`, `price_desc`, `floor_area_desc`, `publication_date_desc` | Sort order |
| `extractDetails` | boolean | No | `false` | `true` / `false` | Collect detail fields and photo gallery (charged as listing details) |
| `extractAgentContact` | boolean | No | `false` | `true` / `false` | Collect agent phone and contact (charged as contact info) |
| `detailConcurrency` | integer | No | `10` | `1`–`50` | Parallel detail requests |
| `maxItems` | integer | No | `100` | `0` (no limit) or positive integer | Maximum listings to collect |
| `proxyConfiguration` | object | No | Apify proxy, `RESIDENTIAL` group | Apify proxy groups or custom proxies | Residential proxies are required for reliable runs |

\* Provide either `startUrls` or `searchQueries` — at least one source is required.

Minimal request:

```json
{ "searchQueries": ["Amsterdam"], "offeringType": "buy" }
```

Advanced request (location search with filters and enrichment):

```json
{
  "searchQueries": ["Amsterdam"],
  "offeringType": "buy",
  "minPrice": 150000,
  "maxPrice": 750000,
  "propertyTypes": ["apartment", "house"],
  "energyLabels": ["A", "B"],
  "exteriorSpaceTypes": ["garden"],
  "availability": "available_and_negotiations",
  "sortBy": "publication_date_desc",
  "extractDetails": true,
  "extractAgentContact": true,
  "maxItems": 500,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Retrieve the data through the API

The Actor runs on the Apify platform, so there is no server to host and no crawling infrastructure to maintain.

1. Start the Actor with a JSON input (console or API).
2. Wait for the run to finish, or use a synchronous endpoint if you want the response inline.
3. Retrieve items from the run's default dataset.
4. Paginate or export the dataset.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")

run_input = {
    "searchQueries": ["Amsterdam"],
    "offeringType": "buy",
    "maxItems": 50,
}

run = client.actor("datascrapers/funda-nl-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["listingId"], item["priceValue"], item["address"])
```

Apify generates ready-to-run Python, JavaScript, and cURL examples on the Actor's API tab. Do not put a real API token in shared code or URLs.

### Data quality and record handling

- **Conditional fields**: detail fields (latitude, longitude, images) are present only when `extractDetails` is enabled; `agentPhone` and `agentContactName` are present only when `extractAgentContact` is enabled.
- **Source changes**: Funda page structure and values can change; unreadable fields are returned as null rather than fabricated.
- **Deduplication**: each run appends fresh records; the Actor does not deduplicate listings across runs. Use `listingId` as the stable key and filter repeated runs against previously stored IDs.
- **Rate limits**: Funda can rate-limit automated traffic; residential proxies are required for reliable runs.
- **Normalization**: `priceValue` is a numeric EUR value while `price` preserves the rendered string with condition; `publicationDate` is an ISO 8601 timestamp.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL / Supabase | Dataset API poll or webhook consumer | Store Dutch property inventory with price history |
| Google Sheets | Apify Google Sheets integration | Share market shortlists with agents |
| BI tools (Looker, Tableau) | Scheduled export via Apify scheduler | Price-per-m² benchmarking by city |
| S3 / cloud storage | Scheduled export + integration | Archival of market snapshots |

### Pricing and cost examples

The Actor uses pay-per-event pricing with three chargeable events, all billed per 1,000 listings:

| Event | Trigger | Rate |
|---|---|---|
| Result | Every listing record pushed to the dataset | $1 per 1,000 |
| Listing details | `extractDetails` enabled, detail page fetched | $1 per 1,000 |
| Contact info | `extractAgentContact` enabled, agent contact retrieved | $1 per 1,000 |

Example costs:

| Records | Configuration | Estimated base cost |
|---:|---|---:|
| 1,000 | Listing only | $1.00 |
| 10,000 | Listing only | $10.00 |
| 1,000 | Listing + details | $2.00 |
| 1,000 | Listing + details + agent contact | $3.00 |

Apify paid plans reduce the per-1,000 rate. Compute units consumed by the run are billed by your Apify plan. Estimates depend on the verified pricing model and the options selected for the run.

### Limitations and responsible data use

- The Actor collects publicly accessible data from Funda pages only.
- Field availability depends on what Funda renders at run time; some values can be null or missing, and site changes can alter fields.
- Detail and agent-contact fields are only collected when their toggles are enabled.
- The Actor does not provide historical snapshots unless you store them yourself.
- Large runs require residential proxies; without them, coverage may degrade due to rate limiting.
- You are responsible for compliance with Funda's terms of service, applicable privacy law, and any contractual obligations before using the data.

### Dataset questions

#### What does one dataset item represent?

One property listing from Funda. Detail-page fields (images, coordinates) and agent-contact fields are nested inside the same record, so a listing with full details still produces a single dataset item.

#### Which field should I use as a unique identifier?

`listingId` is the stable Funda listing identifier and is the recommended deduplication key. The `url` (listing detail URL) is a reasonable secondary key.

#### Are fields nullable or conditional?

Yes. Detail fields (latitude, longitude, images) exist only when `extractDetails` is enabled; `agentPhone` and `agentContactName` exist only when `extractAgentContact` is enabled. Within available records, fields that Funda does not render (for example `neighbourhood` or `energyLabel`) are returned as null.

#### Can I retrieve the records as CSV or JSON?

Yes. The dataset can be exported as JSON, CSV, Excel, XML, or HTML from the Apify Console, and queried through the Dataset API.

#### Does the Actor return historical data?

No. Each run captures the state of the pages at run time. To track price changes over time, schedule repeated runs and store the outputs yourself.

#### What counts as a billable result?

Three pay-per-event charges apply: a result charge for every listing record ($1 per 1,000), a listing-details charge for each detail page fetched ($1 per 1,000), and a contact-info charge for each agent contact retrieved ($1 per 1,000). A listing-only run incurs only the result charge.

#### Which filters can I combine?

The Actor supports price, property type, construction type, floor and plot area, rooms, bedrooms, publication date, availability, energy label, exterior space, construction period, surrounding area, garage, and parking filters. Filters are ignored when `startUrls` are provided, since parameters are read from the URL.

### Related datasets from Data Scrapers

- **[Zoopla Scraper](https://apify.com/datascrapers/zoopla-scraper)** — UK property listings for cross-market housing research alongside Dutch data.
- **[Apartments Scraper](https://apify.com/datascrapers/apartments-scraper)** — US rental listings for comparative market analysis.
- **[Redfin Scraper](https://apify.com/datascrapers/redfin-scraper)** — US property listings and market signals for international real estate datasets.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

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

Paste full Funda search result URLs copied from your browser. Parameters are extracted from the URL; any filter not in the URL is taken from the input fields below. URLs without a location search nationwide. Optional: add Search Locations to restrict to a city when the URL has no selected\_area.

## `searchQueries` (type: `array`):

City names, neighborhoods, or postal codes (e.g. Amsterdam, Rotterdam, 1012AB). Ignored when Funda Search URLs are provided.

## `offeringType` (type: `string`):

Buy or rent. Ignored when Funda Search URLs are provided.

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

Minimum asking price. Buy: total sale price. Rent: monthly rent.

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

Maximum asking price.

## `propertyTypes` (type: `array`):

Leave empty for all property types.

## `constructionType` (type: `string`):

Filter by construction type

## `minFloorArea` (type: `integer`):

Minimum living area in square meters

## `maxFloorArea` (type: `integer`):

Maximum living area in square meters

## `minPlotArea` (type: `integer`):

Minimum plot/land area in square meters

## `maxPlotArea` (type: `integer`):

Maximum plot/land area in square meters

## `minRooms` (type: `integer`):

Minimum number of rooms

## `maxRooms` (type: `integer`):

Maximum number of rooms

## `minBedrooms` (type: `integer`):

Minimum number of bedrooms

## `maxBedrooms` (type: `integer`):

Maximum number of bedrooms

## `publicationDate` (type: `string`):

Show listings published within this time frame

## `availability` (type: `string`):

Filter by availability status

## `energyLabels` (type: `array`):

Leave empty for all energy labels.

## `exteriorSpaceTypes` (type: `array`):

Leave empty for all exterior space types.

## `hasGarden` (type: `boolean`):

Only show properties with a garden (shortcut for Exterior Space Types → Garden)

## `constructionPeriods` (type: `array`):

Leave empty for all construction periods.

## `surroundingTypes` (type: `array`):

Leave empty for all surrounding area types.

## `garageAllGarages` (type: `boolean`):

Filter for properties with any garage type

## `garageBasement` (type: `boolean`):

Filter for properties with a basement garage

## `garageBuiltIn` (type: `boolean`):

Filter for properties with a built-in garage

## `garageCarport` (type: `boolean`):

Filter for properties with a carport

## `garageDetached` (type: `boolean`):

Filter for properties with a detached garage

## `garageAndCarport` (type: `boolean`):

Filter for properties with both garage and carport

## `garagePossible` (type: `boolean`):

Filter for properties where a garage can be built

## `garageLeanTo` (type: `boolean`):

Filter for properties with a lean-to garage

## `garageLockUp` (type: `boolean`):

Filter for properties with a lock-up garage

## `garageParkingSpace` (type: `boolean`):

Filter for properties with a garage parking space

## `garageUnderground` (type: `boolean`):

Filter for properties with an underground garage

## `parkingOnEnclosedProperty` (type: `boolean`):

Filter for parking on enclosed property

## `parkingOnPrivateProperty` (type: `boolean`):

Filter for parking on private property

## `parkingPaidParking` (type: `boolean`):

Filter for paid parking nearby

## `parkingGarage` (type: `boolean`):

Filter for parking garage availability

## `parkingPermits` (type: `boolean`):

Filter for parking permit availability

## `parkingPublic` (type: `boolean`):

Filter for public parking nearby

## `freeTextSearch` (type: `string`):

Search within listing descriptions and details

## `sortBy` (type: `string`):

How to sort the results

## `extractDetails` (type: `boolean`):

When enabled, includes the full listing description, property features, coordinates, and complete photo gallery for each result.

## `extractAgentContact` (type: `boolean`):

When enabled, includes the agent phone number, contact person name, and office details when available.

## `detailConcurrency` (type: `integer`):

Maximum number of listings processed in parallel when detail extraction is enabled.

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

Maximum number of listings to scrape (0 = no limit)

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

Proxy settings. Residential proxy is required for reliable runs on Apify Cloud. The default enables Apify residential proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.funda.nl/zoeken/koop?selected_area=%5B%22amsterdam%22%5D"
    }
  ],
  "searchQueries": [
    "Amsterdam"
  ],
  "offeringType": "buy",
  "propertyTypes": [
    "apartment",
    "house"
  ],
  "publicationDate": "no_preference",
  "availability": "available",
  "energyLabels": [],
  "exteriorSpaceTypes": [],
  "hasGarden": false,
  "constructionPeriods": [],
  "surroundingTypes": [],
  "garageAllGarages": false,
  "garageBasement": false,
  "garageBuiltIn": false,
  "garageCarport": false,
  "garageDetached": false,
  "garageAndCarport": false,
  "garagePossible": false,
  "garageLeanTo": false,
  "garageLockUp": false,
  "garageParkingSpace": false,
  "garageUnderground": false,
  "parkingOnEnclosedProperty": false,
  "parkingOnPrivateProperty": false,
  "parkingPaidParking": false,
  "parkingGarage": false,
  "parkingPermits": false,
  "parkingPublic": false,
  "sortBy": "relevance",
  "extractDetails": false,
  "extractAgentContact": false,
  "detailConcurrency": 10,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped property listings

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

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/funda-nl-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 = {
    "startUrls": [{ "url": "https://www.funda.nl/zoeken/koop?selected_area=%5B%22amsterdam%22%5D" }],
    "searchQueries": ["Amsterdam"],
    "maxItems": 20,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascrapers/funda-nl-scraper"
        }
    }
}

```

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/7GiFefIhWHCxoY4Lo/builds/nuqtxi1Rit1ahAO7A/openapi.json