Skip to main content

Complete Guide: How to Scrape Funda Listings Using Python

Run the Funda Scraper Apify Actor from Python and turn funda.nl searches for homes to buy or rent into structured rows.

Updated 12 min readMarkdown
Complete Guide: How to Scrape Funda Listings Using Python

This guide shows how to extract Dutch property listings from funda.nl with Python: homes for sale and for rent, searched by area, price, property type and size, returned as one structured row per listing. The tool is the Funda Scraper Apify Actor (reventadata/funda-scraper), and you drive it from Python with the official Apify API client.

By the end you will know which inputs the Actor accepts, how it applies them, what a row contains, where its limits are, and how to run it on a schedule. The prerequisites are minimal: Python 3.11 or newer, an Apify account and an API token. Every sample row in this guide comes from a capture of funda.nl dated 7 November 2026, parsed with the Actor's own code.


TL;DR

In this tutorial you will learn to run reventadata/funda-scraper from Python with apify-client, pass a search (offering, areas, objectType, maxPrice and a few size filters), and read back rows with price, address, living area, rooms, energy label and agency. You will also learn the optional includeDetails switch for coordinates and descriptions, the 9,990-result ceiling Funda enforces per search, and how to repeat a search on a schedule. The Actor is on the Funda Scraper Store page. The outcome is a short script that prints one summary per listing.


Prerequisites and setup

You need an Apify account, a Python 3.11+ environment and an API token. Apify accounts can be created with an email address or a GitHub login. Apify Console is the web workspace where you manage Actors, runs and datasets; your token is under Settings > API & Integrations.

Install the client and export the token so the script can read it from the environment:

pip install -U "apify-client~=3.0"
export APIFY_API_TOKEN="your_apify_token_here"

Details of the client are in the Apify API client for Python docs. Nothing else is required: no browser, no proxy setup, no scraping library, and no code to maintain on your side.


Understanding Funda Scraper

The Actor runs the same searches as the funda.nl search page, either for sale (koop) or for rent (huur), for one or more areas, and returns one row per listing. A result page holds 15 listings.

The row has 38 fields: price and how Funda labels it, the address split into street, number, postal code, city, district and neighbourhood, living and plot area, rooms, bedrooms, energy label, publication time, open-house windows, photo links, and the listing agency with the named broker where Funda shows one. With includeDetails the Actor also opens every kept listing's own page for coordinates, the description and the feature table.

Limits to know up front. Funda serves at most 666 pages of results (9,990 listings) for one search. The Actor offers filters for price, property type, living area and bedrooms, but not for rooms, energy label or new-build; filter those downstream. Funda's terms of use restrict automated collection, so check that your use complies with them and with data-protection law.


Step-by-step walkthrough

Step 1: Open the Actor

Go to the Funda Scraper page on Apify Store and use Try for free to open it in Apify Console. For the API route in this guide you only need its name, reventadata/funda-scraper.

Step 2: Choose the input

The input form and the API take the same fields:

Field Meaning
offering sale or rent (default sale). Other values are refused before the run starts.
areas List of Funda area slugs, one search per area. Empty means the whole Netherlands.
objectType Empty for every type, house or apartment.
sort relevance (default) or newest.
maxPrice, minPrice EUR; monthly rent for rentals.
minLivingAreaM2, maxLivingAreaM2, minBedrooms Applied after each page is read.
includeDetails One extra request per kept row, for coordinates, description and features.
maxItems, maxPages Row cap (default 100) and pages per area (default 5, at most 666).

Area slugs are the ones in the selected_area part of a funda.nl search URL, for example amsterdam or utrecht. An unknown but well-formed slug returns no results; a malformed one ends the run with an input message.

The Python script in Step 3 sets rentals in Utrecht up to 1,500 EUR a month, one page, in its run_input. For a different shape, this input searches two towns for larger apartments for sale:

{
    "offering": "sale",
    "areas": ["amsterdam", "utrecht"],
    "objectType": "apartment",
    "minLivingAreaM2": 60,
    "minBedrooms": 2,
    "maxItems": 30,
    "maxPages": 3
}

When maxPrice is set, the price range goes to Funda (with minPrice as the lower bound when you give one). A minPrice on its own is applied after fetching, so it removes rows but not pages.

Step 3: Run the Actor from Python

import os
from apify_client import ApifyClient

# 1. Initialise the client with your token from the environment
client = ApifyClient(os.environ["APIFY_API_TOKEN"])

# 2. Describe the search: rentals in Utrecht up to 1,500 EUR a month
run_input = {
    "offering": "rent",
    "areas": ["utrecht"],
    "maxPrice": 1500,
    "maxItems": 15,
    "maxPages": 1,
}

# 3. Start the Actor and wait for it to finish
run = client.actor("reventadata/funda-scraper").call(run_input=run_input)
if run is None or run.status != "SUCCEEDED":
    status = run.status if run else "unknown"
    raise SystemExit(f"Run did not succeed (status: {status}).")

# 4. Read the rows from the run's default dataset
items = client.dataset(run.default_dataset_id).list_items().items
print(f"Retrieved {len(items)} listings.\n")

# 5. Print two lines per listing, with a price per square metre worked out here
for item in items:
    street = " ".join(
        part for part in (item.get("street"), item.get("houseNumber"), item.get("houseNumberSuffix")) if part
    )
    price, area = item.get("price"), item.get("livingAreaM2")
    per_m2 = f"{price / area:.1f} EUR/m2" if price and area else "no living area"
    print(f"{street}, {item.get('city')} | {price} EUR/month | {area} m2 | {per_m2}")
    print(f"  {item.get('propertyType')}, bedrooms: {item.get('bedrooms')}, energy label: {item.get('energyLabel')}")

The script checks the run status before it reads anything, so a failed run stops with a clear message instead of an empty loop.

Step 4: Examine the output

On a capture dated 2026-11-07 of that Utrecht rental search (17 results, 15 on page 1), the loop prints this at the start:

Koningsweg 135 E, Utrecht | 290 EUR/month | None m2 | no living area
  parking, bedrooms: None, energy label: unknown
Hooft Graaflandstraat 2 A9, Utrecht | 1425 EUR/month | 27 m2 | 52.8 EUR/m2
  apartment, bedrooms: 1, energy label: A++++
Oranje Vrijbuiterslaan 55, Utrecht | 1132 EUR/month | 48 m2 | 23.6 EUR/m2
  apartment, bedrooms: 1, energy label: A

The first listing is a parking space, which has no living area and no bedrooms. The default objectType is empty, so parking spaces and storage units come back with the homes; 5 of the 15 rows on that page were of that kind.

Step 5: Add coordinates and descriptions

With includeDetails set to true the detail fields are filled. This is the detail part of one rental listing's page from the same day (description and features shortened):

{
    "latitude": 52.074806,
    "longitude": 5.119643,
    "description": "Karakteristiek appartement met patio en uitzicht over de Vaartsche Rijn! ...",
    "features": {
        "Aangeboden sinds": "November 6, 2026",
        "Huurprijs": "€ 1.950 per maand (geen servicekosten)",
        "Waarborgsom": "€ 3.900 eenmalig",
        "Soort bouw": "Bestaande bouw",
        "Bouwjaar": "1920",
        "Wonen": "85 m²",
        "Aantal kamers": "2 kamers (1 slaapkamer)",
        "Verwarming": "Gehele vloerverwarming"
    }
}

If a detail page cannot be read, the row is still delivered with those four fields null and the run logs a warning with the count.

Step 6: Export the data

Datasets export as JSON, CSV, XML, Excel, HTML table, RSS or JSONL from Console, and through the API with the format parameter (dataset docs). The dataset schema defines an overview view with url, listing type, price, city, postal code, street, house number, living area, bedrooms, energy label and agency.


Working with the API

The script above uses three calls of the Apify client for Python: client.actor("reventadata/funda-scraper").call(run_input=...) starts a run and waits for it, run.status and run.default_dataset_id come from the typed run object it returns, and client.dataset(...).list_items().items reads the rows. The token authenticates all of them; keep it in an environment variable, never in the script.

To react to a finished run without waiting in a script, add a webhook. Its payload resource is the response of the Get Actor run API call, which includes defaultDatasetId (webhook docs), so your application can fetch the rows by itself.

For repeated searches, save the input as an Apify task and attach a schedule, which runs an Actor or task on a cron expression.

For error handling, check run.status as the script does and read the run log with client.log(run.id).get(). The log ends with Skipped N: reason lines for rows your limits removed and a Pushed N row(s). line. A run that saves nothing ends in one of two ways: SUCCEEDED with a status message when funda.nl answered but nothing matched, FAILED when pages could not be read or the input was invalid. A run stops early when pages keep failing, and rows saved before that are kept.


Advanced usage patterns

Several towns in one run. Put them all in areas. Each town is a separate search, and a listing that appears in two of them is stored once, by its Funda id.

Getting past the ceiling. A search larger than 9,990 results is cut off by Funda, and the run logs a warning. Slice it instead: run the same area several times with different price bands (minPrice together with maxPrice), or by objectType, and merge on id. The Actor only removes duplicates within one run, so merging across runs is yours to do.

Monitoring new listings. Use sort: "newest" with a small maxPages on a schedule, and keep the id values you have already seen. publishedAt carries the publication time.

Sorting and ranking. The rows have no derived fields, which keeps them faithful to the page. Work out price per square metre, as the script does, or group by energyLabel, district or agencyName in pandas or a spreadsheet.

Volume bounds. maxItems stops the run once that many rows are stored, and maxPages limits the pages read per area. Start with maxPages: 1 while you check the shape of the data, then raise the caps step by step as you trust the filters you chose.


Understanding your data

Each field follows the dataset schema. price is the asking price; priceCondition says how to read it (per_month on rentals, kosten_koper on sales). propertyType is as Funda publishes it: apartment, house, parking, storage_space and others. constructionType separates resale from newly_built. Missing values are null, never zero: a parking space has no livingAreaM2 and no bedrooms. energyLabel is "unknown" without a stated label (10 of 15 Utrecht rows).

The address fields keep Funda's own wording, such as the district Wijk 07 Zuid. agencyName and agencyUrl identify the listing agency; brokerName is filled only when the listing names a broker.

One complete row from the capture (imageUrls cut to its first entry):

{
    "id": "8178650",
    "url": "https://www.funda.nl/detail/huur/utrecht/appartement-hooft-graaflandstraat-2-a9/80987659/",
    "listingType": "rent",
    "price": 1425,
    "priceType": "regular",
    "priceCondition": "per_month",
    "currency": "EUR",
    "propertyType": "apartment",
    "constructionType": "resale",
    "status": "none",
    "street": "Hooft Graaflandstraat",
    "houseNumber": "2",
    "houseNumberSuffix": "A9",
    "postalCode": "3525VV",
    "city": "Utrecht",
    "municipality": "Utrecht",
    "province": "Utrecht",
    "district": "Wijk 07 Zuid",
    "neighbourhood": "Nieuw Hoograven-Zuid",
    "livingAreaM2": 27,
    "plotAreaM2": null,
    "rooms": 2,
    "bedrooms": 1,
    "energyLabel": "A++++",
    "publishedAt": "2026-10-05T15:49:58.8659613+02:00",
    "promoText": null,
    "imageUrls": [
        "https://cloud.funda.nl/tiara-media/64c806c0-d856-4ab7-be06-c84e811130e4/875e471e-0738-4a5c-bcf2-6d1f795314f4"
    ],
    "agencyName": "Otten en Stok Makelaars",
    "agencyUrl": "https://www.funda.nl/makelaar/63878-otten-en-stok-makelaars/",
    "agencyId": 63878,
    "agencyAssociation": "VN",
    "brokerName": null,
    "openHouses": [],
    "searchUrl": "https://www.funda.nl/zoeken/huur?selected_area=%5B%22utrecht%22%5D&price=%220-1500%22&search_result=1",
    "latitude": null,
    "longitude": null,
    "description": null,
    "features": null
}

Troubleshooting guide

The run succeeded with zero rows. Funda answered, but nothing matched, or the area slug is unknown. The run's status message says so. Check the slug against a funda.nl URL and loosen the filters.

The run failed with zero rows. Either the input is invalid (a malformed slug, or maxPrice below minPrice), in which case the message says what to fix, or pages could not be read, which the log shows page by page. Run again later with maxPages: 1 before widening.

Fewer rows than the site reports. Your limits drop rows after each page is read, and the Skipped N: reason lines in the log give the counts. A living-area or bedroom limit also drops rows that have no such value.

Rows with null fields. Parking spaces, storage units and plots have no bedrooms or living area; use objectType to avoid them.

Where to look. The run page in Console shows status and log; the log is also available through the API as shown above. For help, use the Actor's Store page.


Best practices

Keep the first run small: maxPages: 1 and a maxItems of 15 show the field shapes before you commit to a long search. Set objectType unless you want parking and storage rows. Prefer filters that Funda applies itself (maxPrice with minPrice, objectType) over post-fetch filters, because they reduce the number of pages the Actor must read. Treat null as a value to handle, not an error. Store the Funda id with every record so later runs can be compared. Listings change, so the data describes the moment of the fetch. Finally, honour Funda's terms and data-protection rules for any personal data in your use.


Conclusion and next steps

You now have a script that runs reventadata/funda-scraper, checks the run status, reads the rows and prints a price per square metre next to each listing. From here, try sort: "newest" on a schedule, add includeDetails for coordinates, or slice a large search by price band.

For current pricing and details, see the Store page.

Try Funda Scraper yourself and let me know what you build!


Resources

About the author: reventadata builds and publishes data extraction Actors on the Apify Store.

About the author

  • Hi, I'm the engineer behind ReventaData. I build pay-per-event Apify Actors that turn public marketplace, classifieds, jobs and real-estate sites into clean, reliable datasets. Here on Hashnode, I share practical tutorials on collecting structured web data with Python and Apify, and on putting it to work: price tracking, lead lists and market analysis. Explore our turnkey scrapers: https://apify.com/reventadata

No comments yet. Be the first to comment.