# Zimmo Listings Scraper ($0.50/1K) (`carabain-digital/zimmo-listings`) Actor

Scrape real-estate listings from Zimmo (zimmo.be), Belgium: houses, apartments, land and commercial property for sale and for rent. Filter by city or postcode, price, bedrooms, living area and type. Price, address, EPC, agent, photos and the site's own price history. Fast, no proxy needed.

- **URL**: https://apify.com/carabain-digital/zimmo-listings.md
- **Developed by:** [Carabain Digital](https://apify.com/carabain-digital) (community)
- **Categories:** Real estate, Lead generation
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

#### What is Zimmo Listings Scraper?

**Zimmo Listings Scraper** scrapes **property listings from Zimmo ([zimmo.be](https://www.zimmo.be))**, a major Belgian property portal with more than 60,000 properties for sale plus thousands of rentals, many of them from notaries and independent agents. Search by **city or postcode, sale or rent, property type, price range, bedrooms and living area**, or paste a search URL from the site, and get clean, flat listing data as JSON, CSV, Excel, XML or HTML: price, address, coordinates, living and plot area, bedrooms, EPC label, agent contact, photos and description. Prefilled example: the 20 newest properties for sale in Gent, ready in seconds. Costs **$0.50 per 1,000 listings**. Add-ons: **Price history** (price changes over time) for $1.00 per 1,000 listings. Zimmo's search already includes the full description and the agent's phone, so there is no separate details add-on.

- 🔎 **Search like on the site**: city or postcode, sale or rent, property type, price range, bedrooms, living area, or paste a Zimmo search URL
- ⚡ **Fast and cheap**: plain HTTP, no browser and no proxy needed, 200 listings in about 4 seconds
- 📉 **Price changes included**: Zimmo's own price history (`site_price_history`) and the date of the last price drop on every listing
- 📈 **Track prices over time**: switch on **Price history** to compare every run with the last one
- 🔌 **Connect anywhere**: API, schedules, webhooks, Google Sheets, Make, Zapier, MCP / AI agents

#### What data can I extract from Zimmo?

<table>
<tr><td>🆔 Stable listing ID and URL</td><td>💶 Price (sale) or monthly rent</td></tr>
<tr><td>📍 Address, postcode, city, province</td><td>🧭 Latitude and longitude</td></tr>
<tr><td>🏠 Property type and subtype</td><td>📐 Living area and plot area (m²)</td></tr>
<tr><td>🛏️ Bedrooms and bathrooms</td><td>⚡ EPC energy label</td></tr>
<tr><td>🏷️ Status: available, under offer, sold, rented</td><td>📅 Listed and last-updated date</td></tr>
<tr><td>🏢 Agent name, phone and website</td><td>📷 Photo URLs</td></tr>
<tr><td>📝 Description</td><td>📉 Zimmo's price history and last price-drop date</td></tr>
</table>

Zimmo gives the full description, all photos and the agent's phone in the search results, so you get them without any add-on. `rooms` (total room count) is not published by Zimmo and stays `null`; `living_area_m2` is empty for land and for some garages and apartments.

#### How do I scrape Zimmo listings?

1. [Create a free Apify account](https://console.apify.com/sign-up) and open this Actor.
2. Enter a **Location** (for example `Gent` or `9000`), pick **Sale or rent** and, if you like, a property type and price range. Or paste one or more **Search URLs** copied from zimmo.be.
3. Set **Max listings** (the newest come first).
4. Click **Start**, then download the listings from the **Output** tab as JSON, CSV, Excel, XML or HTML.

#### How much does it cost to scrape Zimmo?

You pay per listing that ends up in your dataset: **$0.50 per 1,000 listings**, no subscription. The monthly credit of Apify's Free plan ($5) covers around 10,000 listings without add-ons. Paid plans get volume discounts.

- **Add-on: Price history, $1.00 per 1,000 listings** (off by default). Adds `first_seen_at`, `previous_price`, `price_change`, `price_change_pct`, `status_changed` and `price_history`. Charged only for listings that already had history from an earlier run, so the first run is free. See the *Price history* section below.
- Failed runs and empty searches cost nothing; you can cap spending with **Maximum cost per run** in the run options.

See the **Pricing** tab for the current prices.

#### ⬇️ Input

| Field | Description |
|---|---|
| **Location** (`location`) | City, municipality or postcode; several separated by commas |
| **Sale or rent** (`listing_type`) | `sale` or `rent` |
| **Property type** (`property_type`) | `any`, `house`, `apartment`, `land`, `commercial`, `parking`, `room` (kot) |
| **Minimum / maximum price** (`min_price`, `max_price`) | In euro; for rentals per month |
| **Minimum bedrooms** (`min_rooms`) | Number of bedrooms |
| **Minimum living area** (`min_living_area_m2`) | In m²; listings without a known area are left out |
| **Search URLs** (`start_urls`) | Search pages copied from zimmo.be; they replace the filters above |
| **Max listings** (`limit`) | Stop after this many listings |
| **Price history** (`trackHistory`) | Paid add-on: compare with your previous runs |
| **History store name** (`historyStoreName`) | Where the history is kept (default `realestate-history`) |
| **Proxy** (`proxyConfiguration`) | Not needed for Zimmo |

```json
{
    "location": "Gent",
    "listing_type": "sale",
    "limit": 20
}
```

Zimmo returns the newest listings first (by creation date). With **Search URLs** you can paste a place page like `https://www.zimmo.be/nl/gent/te-koop/appartement` or an advanced-search URL (`https://www.zimmo.be/nl/uitgebreid-zoeken?search=...`); a page number in the URL is ignored and the Actor reads as many pages as **Max listings** needs.

#### ⬆️ Output

Listings are stored in the default dataset, newest first. View them as a table in the **Output** tab or export JSON, CSV, Excel, XML or HTML. Fields a listing does not have are `null`; every item has the same keys.

##### A listing (sale, with Zimmo's price history)

```json
{
    "id": "zimmo:LSSH9",
    "source": "zimmo",
    "url": "https://www.zimmo.be/nl/gent-9000/te-koop/appartement/LSSH9",
    "title": null,
    "listing_type": "sale",
    "property_type": "apartment",
    "property_subtype": "apartment",
    "status": "available",
    "price": 550000,
    "price_currency": "EUR",
    "price_period": null,
    "price_type": "asking",
    "address": "Raketstraat 1A, 9000 Gent",
    "street": "Raketstraat",
    "house_number": "1A",
    "postcode": "9000",
    "city": "Gent",
    "region": "East Flanders",
    "country": "BE",
    "lat": 51.04035569,
    "lon": 3.71145467,
    "living_area_m2": 85,
    "plot_area_m2": null,
    "rooms": null,
    "bedrooms": 2,
    "bathrooms": 1,
    "energy_label": "A",
    "construction_year": 2024,
    "listed_at": "2026-10-29T12:38:51Z",
    "updated_at": "2026-10-30T12:45:07Z",
    "agent_name": "IMMO CVH",
    "agent_phone": "+32 9 311 92 99",
    "agent_url": "http://www.immo-cvh.be",
    "image_urls": [
        "https://files.zimmo.be/backend-api/x4E7PnT5YgI-19KKZboyQIO9rd0=/fit-in/1200x1200/filters:image-format(pjpg)/-/real-estate/customers/b53651cc-4bae-11e9-922b-005056b768a1/dealers/130178e2-0541-4f84-8bcc-41686167924b/listings/5e0bbbd3-3641-440e-8f00-44f346b1deb2/images/01a18cb1-db5c-7d5b-9e20-bc67a2c36716",
        "https://files.zimmo.be/backend-api/Jx2B8Tze5vA4WZ3sXmvHi81wQfs=/fit-in/1200x1200/filters:image-format(pjpg)/-/real-estate/customers/b53651cc-4bae-11e9-922b-005056b768a1/dealers/130178e2-0541-4f84-8bcc-41686167924b/listings/5e0bbbd3-3641-440e-8f00-44f346b1deb2/images/01a18cb1-db6f-7c5f-b7b0-835b54919304",
        "..."
    ],
    "description": "Dit instapklaar BEN-appartement bevindt zich op de eerste verdieping van residentie Gandhon, een prachtige ontwikkeling gelegen in de Raketstraat te Gent. Kenmerkend aan deze uitstekende locatie is de directe nabijheid van het station Gent Sint-Pieters, de ...",
    "site_price_history": [
        {
            "date": "2026-10-30T12:03:46Z",
            "price_before": 500000,
            "price_after": 550000
        }
    ],
    "price_drop_date": null,
    "scraped_at": "2026-10-30T14:57:04Z"
}
```

##### Extra fields with the Price history add-on

```json
{
    "first_seen_at": "2026-10-23T07:00:12+00:00",
    "previous_price": 575000,
    "price_change": -25000,
    "price_change_pct": -4.35,
    "status_changed": false,
    "price_history": [
        { "at": "2026-10-23T07:00:12+00:00", "price": 575000, "status": "available" },
        { "at": "2026-10-30T07:00:09+00:00", "price": 550000, "status": "available" }
    ]
}
```

#### What can I do with Zimmo data?

- 📉 **Price drop alerts**: schedule a run with **Price history** and get notified when `price_change` is negative
- 🏘️ **Market research**: asking prices per m² per postcode, new supply per week, time on market
- 🔎 **Deal finding and investment**: filter by price, area and EPC label, compare rent and sale prices per neighbourhood
- 📇 **Lead generation**: agents and notaries with their active listings per region
- 🧠 **AI and analytics**: feed descriptions and attributes into valuation models or LLM pipelines

#### Tips for best results

- **Zimmo returns at most about 9,950 results per search** (the site stops paging at 9,900). To collect more, split the search: by city or postcode, by property type, or by price range, and run them as separate searches or as several **Search URLs**.
- For a daily feed, schedule a run with a high **Max listings** and **Price history** switched on; the newest listings come first.
- **Sale** includes properties for sale and "overname" (take-over) listings; **rent** includes rentals. Sold and rented properties are not returned unless your pasted search URL asks for them (then `status` is `sold` or `rented`).
- New-build projects (developments) are skipped; their individual units are normal listings and are included.
- Results from one run are deduplicated by listing ID.

#### Price history

Switch on **Price history** (`trackHistory`) and the Actor remembers every listing between runs, so you can see price drops, status changes and how long a property has been on the market.

- **Where it lives.** History is kept in a *named key-value store in your own Apify account* (default name `realestate-history`, change it with **History store name**). Named stores never expire, you own the data, and storage costs a fraction of a cent.
- **First run starts the series.** The first time a listing is seen there is nothing to compare with, so `previous_price` is `null` and you are not charged for the add-on on that listing. From the second run on, each listing gets `first_seen_at`, `previous_price`, `price_change`, `price_change_pct`, `status_changed` and `price_history` (the last 20 price/status points, one point per change).
- **Run it on a schedule.** History only grows when you run the Actor. Create a [schedule](https://docs.apify.com/platform/schedules) (daily is typical) with the same search and the same store name.
- **One store, several Actors.** Every real-estate Actor we publish uses the same default store name, so a listing keeps one history even if you scrape it with a different one of our Actors. Item IDs start with the site (`zimmo:...`), so sites never clash. Use a different store name per search if you want separate series.
- **Do not run two runs on the same store at the same time.** Records are updated per listing and the last writer wins, so two parallel runs can overwrite each other's newest point. Run searches that share a store one after another.
- **If you delete the store,** the Actor starts a new empty history without an error.
- **Cost:** $1.00 per 1,000 listings that already had history (see pricing above).
- Zimmo also publishes its own price changes for most listings (`site_price_history`, `price_drop_date`). They are free and always on, but only go back as far as the agent's edits on the site; **Price history** adds your own series from your first run, including status changes.

#### Frequently asked questions

#### Can I use Zimmo Listings Scraper with the Apify API?

Yes. Every run has a dataset you can read through the [Apify API](https://docs.apify.com/api/v2). Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("carabain-digital/zimmo-listings").call(run_input={
    "location": "Gent",
    "listing_type": "sale",
    "property_type": "house",
    "max_price": 450000,
    "limit": 100,
})
for home in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(home["price"], home["address"], home["living_area_m2"], "m2")
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('carabain-digital/zimmo-listings').call({
    location: 'Gent',
    listing_type: 'sale',
    property_type: 'house',
    max_price: 450000,
    limit: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'listings');
```

#### Can I use Zimmo Listings Scraper through an MCP server or with AI agents?

Yes. Add it to an AI agent through the [Apify MCP server](https://mcp.apify.com) (`https://mcp.apify.com?tools=carabain-digital/zimmo-listings`), or let the agent find it with `search-actors` and run it with `call-actor`. A small search (`limit` 20) finishes in about a second, and the items are flat and small, so agents can read them with `get-dataset-items`. Example prompt: *"Use Zimmo Listings Scraper to list the 20 newest apartments for rent in Antwerp under 1,500 euro and tell me which have an A or B energy label."*

#### Can I integrate Zimmo data with other apps?

Yes: Google Sheets, Slack, Make, Zapier, n8n, Airtable or your own webhook, through Apify [integrations](https://apify.com/integrations) and [webhooks](https://docs.apify.com/platform/integrations/webhooks). Schedule a run every morning and send the new listings or price drops to your inbox or CRM.

#### Why is a field empty?

Zimmo does not publish a room count (`rooms`), and many listings have no title (`title`), living area (garages, land), construction year or EPC label. Those fields are `null`. The agent's phone and website are `null` for some private sellers and notaries.

#### What is the difference between `site_price_history` and `price_history`?

`site_price_history` is what Zimmo itself shows: the price changes the agent made on the site, `[{date, price_before, price_after}]`. `price_history` comes from the **Price history** add-on and is built from *your* runs: one point whenever the price or status changed between two of your runs. Use the first for listings that are already old, the second to monitor anything over time.

#### Does it cover sold and rented properties?

Not by default. Searches return what is currently for sale or for rent. `status` is `under_offer` for listings the agent has marked as under option, and `sold` or `rented` only when a pasted search URL includes sold or rented properties.

#### Does it cover Wallonia and Brussels?

Yes: Zimmo lists properties across Belgium. Use a city, postcode or leave **Location** empty for all of Belgium.

#### Is it legal to scrape Zimmo?

The Actor only collects publicly visible listings, the same data anyone can see on zimmo.be. Listings can contain personal data (for example the name or phone number of a private seller or agent), and rules such as GDPR may apply to how you store and use it. Check your use case with a lawyer. More background: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

#### Zimmo Listings Scraper not working? Feedback

Open an issue on the **Issues** tab of this Actor with the run link and we will look at it. Feature ideas are welcome there too.

#### Other scrapers by us

| Actor | Covers |
|---|---|
| [Immoweb Listings Scraper](https://apify.com/carabain-digital/immoweb-listings) | Belgium: immoweb.be, the biggest Belgian property portal |
| [Immovlan Listings Scraper](https://apify.com/carabain-digital/immovlan-listings) | Belgium: immovlan.be |
| [Huislijn Listings Scraper](https://apify.com/carabain-digital/huislijn-listings) | Netherlands: huislijn.nl |
| [Pararius Listings Scraper](https://apify.com/carabain-digital/pararius-listings) | Netherlands: pararius.nl, rentals and sales |
| [Belgium Real Estate Scraper](https://apify.com/carabain-digital/belgium-real-estate) | Zimmo, Immoweb and Immovlan in one run, merged and deduplicated |

⭐ **Does it work well for you?** A review on the Store page helps others find this Actor and helps us keep it maintained.

# Actor input Schema

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

Belgian city, municipality or postcode. Several values separated by commas (all postcodes or all names). Example: `Gent`, `Antwerpen` or `9000, 9050`. Leave empty for all of Belgium. Ignored when you give search URLs.

## `listing_type` (type: `string`):

`sale` for properties to buy, `rent` for rentals. Example: `rent`.

## `property_type` (type: `string`):

Type of property. `any` = all types. Example: `apartment`.

## `min_price` (type: `integer`):

Lowest price in euro (rent: per month). Example: `200000`, for rent `800`.

## `max_price` (type: `integer`):

Highest price in euro (rent: per month). Example: `450000`, for rent `1500`.

## `min_rooms` (type: `integer`):

Minimum number of bedrooms. Example: `2`.

## `min_living_area_m2` (type: `integer`):

Minimum living area in square metres. Listings without a known area are left out when this is set. Example: `80`.

## `start_urls` (type: `array`):

Search result pages copied from zimmo.be; they replace the filters above. Example: `https://www.zimmo.be/nl/gent/te-koop/appartement` or an advanced-search URL (`/nl/uitgebreid-zoeken?search=...`). Leave empty to use the filters above.

## `limit` (type: `integer`):

Stop after this many listings (newest first). Example: `100`. Zimmo returns at most about 9,950 results per search: use a place or price range to go deeper.

## `trackHistory` (type: `boolean`):

Keep the price and status of every listing in a named store in your own Apify account and add first_seen_at, previous_price, price_change, price_change_pct, status_changed and price_history to each item. Run it on a schedule: the first run only starts the series. Adds $1.00 per 1,000 listings that already had history. Do not run two runs on the same store at once.

## `historyStoreName` (type: `string`):

Name of the key-value store that holds the history (letters a-z, digits, dashes). All our real-estate Actors use `realestate-history` by default, so history is shared between them. Use another name to keep a separate series per search, e.g. `gent-apartments`.

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

Zimmo works without a proxy. Enable one only if runs get blocked.

## Actor input object example

```json
{
  "location": "Gent",
  "listing_type": "sale",
  "property_type": "any",
  "limit": 20,
  "trackHistory": false,
  "historyStoreName": "realestate-history",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

All scraped listings, one item per property.

# 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 = {
    "location": "Gent",
    "limit": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("carabain-digital/zimmo-listings").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 = {
    "location": "Gent",
    "limit": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("carabain-digital/zimmo-listings").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 '{
  "location": "Gent",
  "limit": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call carabain-digital/zimmo-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,carabain-digital/zimmo-listings"
        }
    }
}
```

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/l9WiluPbd17Rq1Bmj/builds/8TpCEqqepmebdhEiR/openapi.json
