# Immoweb Property Extractor (`kawsar/immoweb-property-extractor`) Actor

Immoweb property extractor that gathers property listings, prices, and locations from Immoweb.be. It lets real estate investors and analysts track housing market trends without clicking through pages manually.

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

## Pricing

from $2.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

## Immoweb Property Extractor

Immoweb Property Extractor is a powerful, high-performance web scraping tool designed to collect comprehensive property listings directly from Immoweb.be. It allows you to extract real estate pricing, precise locations, physical dimensions, construction details, and agency information into structured datasets.

Whether you are conducting real estate market research, monitoring competitor listings, or identifying high-yield property investment opportunities in Belgium, this extractor delivers reliable, clean, and structured data in formats such as JSON, CSV, and Excel.

### Key Features

- **Multi-URL Support**: Paste search result URLs, direct property classified URLs, or a combination of both.
- **Smart Search Pagination**: Automatically detects and navigates multi-page search lists sequentially to ensure no properties are skipped.
- **Per-URL Limit Enforcement**: Control your extraction budget easily with a dedicated per-URL limit.
- **Robust Detail Extraction**: Automatically extracts extensive attributes including pricing, bedroom/bathroom counts, living and land areas, EPC scores, construction year, and building condition.
- **Clean Datasets**: Outputs normalized records and automatically filters out null or empty fields to provide ready-to-use tables.
- **Resilient Request Routing**: Built-in intelligent anti-blocking mechanisms automatically manage connection routing, rotation, and retries, ensuring a seamless scraping experience with no proxy configuration required.

### How It Works

1. **Paste Starting URLs**: Enter one or more Immoweb.be URLs. You can use standard search queries (e.g., houses for sale in a specific region) or direct listing links.
2. **Set Item Limits**: Configure the maximum number of items to extract from each individual search URL (default is 30 listings).
3. **Execute the Scraper**: The actor launches, accesses pages via an optimized delivery layer, parses cards from search lists, follows pagination sequentially, and handles direct listing details as fallbacks.
4. **Export Clean Data**: Access your structured dataset instantly in JSON, CSV, Excel, or XML formats via the Apify platform.

### Input Configuration Reference

The extractor is designed to be user-friendly. Below is the input configuration reference:

| Field Name | Type | Description | Default |
| :--- | :--- | :--- | :--- |
| `urls` | Array of Strings | A list of Immoweb.be search results URLs or direct property classified URLs. | (Required) |
| `maxItems` | Integer | The maximum number of property listings to extract **per input URL**. Use this to control the depth of your crawl. | `30` |
| `requestTimeoutSecs` | Integer | Connection and request timeout limit in seconds. | `30` |

### Extracted Data Schema

The actor extracts the following fields for each listing when available:

| Field Name | Data Type | Description |
| :--- | :--- | :--- |
| `id` | String | The unique listing identifier on Immoweb.be |
| `url` | String | The direct canonical URL to the property detail page |
| `propertyTitle` | String | The title or headline of the property listing |
| `propertyType` | String | General property category (e.g., house, apartment, property) |
| `propertySubtype` | String | Specific subtype of the listing (e.g., villa, penthouse, loft, chalet) |
| `price` | Integer | Price of the property in EUR |
| `bedroomCount` | Integer | Number of bedrooms in the property |
| `bathroomCount` | Integer | Number of bathrooms (available on direct listing URLs) |
| `livingArea` | Integer | Habitable surface area in square meters |
| `landArea` | Integer | Total plot or land surface area in square meters |
| `constructionYear` | Integer | Year of construction (available on direct listing URLs) |
| `buildingCondition` | String | Physical condition of the property (e.g., as new, good, to renovate) |
| `epcScore` | String | Energy Performance Certificate rating (e.g., A, B, C, D, E, F) |
| `locality` | String | City or municipality where the property is situated |
| `postalCode` | String | Belgian postal code of the property |
| `latitude` | Number | Geographical coordinate latitude |
| `longitude` | Number | Geographical coordinate longitude |
| `agencyName` | String | Name of the listing real estate agency or broker |
| `agencyPhone` | String | Contact telephone number of the agency or seller |
| `propertyImages` | Array of Strings | List of URLs to the listing photographs |
| `scrapedAt` | String | ISO timestamp indicating when the property was scraped |

### Sample JSON Output

Below is an example of a parsed property listing produced by this extractor:

```json
{
  "id": "21613952",
  "url": "https://www.immoweb.be/en/classified/house/for-sale/voeren/3790/21613952",
  "propertyTitle": "Charming country house for sale in Voeren",
  "propertyType": "house",
  "propertySubtype": "house",
  "price": 385000,
  "bedroomCount": 3,
  "bathroomCount": 2,
  "livingArea": 165,
  "landArea": 820,
  "constructionYear": 1985,
  "buildingCondition": "good",
  "epcScore": "C",
  "locality": "Voeren",
  "postalCode": "3790",
  "latitude": 50.7584,
  "longitude": 5.7892,
  "agencyName": "Immo Voeren",
  "agencyPhone": "+32 475 12 34 56",
  "propertyImages": [
    "https://static.immoweb.be/media/pictures/21613952/image1.jpg",
    "https://static.immoweb.be/media/pictures/21613952/image2.jpg"
  ],
  "scrapedAt": "2026-06-07T05:39:23.182Z"
}
````

### Practical Use Cases

- **Market Analysis**: Calculate average prices, median size, and pricing trends across different zip codes in Belgium.
- **Lead Generation**: Identify active real estate brokers and retrieve agency contacts for commercial partnerships or services.
- **Investment Screening**: Find underpriced properties or fixer-ups by filtering listings with specific building conditions and low EPC scores.
- **Portfolio Monitoring**: Automatically keep track of new residential listings on Immoweb.be matching your specific search parameters.

### Frequently Asked Questions

**Do I need custom proxies to use this extractor?**
No. The extractor operates with built-in, automated resilient request routing that handles IP rotation and overcomes anti-blocking barriers seamlessly. No additional proxy subscriptions or credentials are required.

**What is the difference between global and per-URL limits?**
The `maxItems` limit applies strictly **per input URL**. If you provide 3 search URLs and set `maxItems` to 30, the actor can scrape up to 30 items from the first URL, up to 30 from the second URL, and up to 30 from the third URL (for a total of up to 90 items). This design is highly optimized for gathering deep, targeted samples from multiple unique search criteria in a single run.

**Why are some fields missing from some results?**
Immoweb.be search results page cards display a subset of information (like location, price, type, bedrooms, and living area). Direct property pages contain deeper structural details (such as construction year, building condition, bathrooms, and agency phone numbers). The extractor collects all available details from search cards. If you need complete structural details for every single listing, you can paste direct listing URLs as inputs.

# Actor input Schema

## `urls` (type: `array`):

Provide Immoweb.be search results URLs or direct listing URLs. The scraper will extract details for all matched listings.

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

Maximum number of property listings to extract details for per input URL.

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

Per-request timeout in seconds for fetching from the website.

## Actor input object example

```json
{
  "urls": [
    "https://www.immoweb.be/en/classified/apartment/for-sale/anderlecht/1070/11054321"
  ],
  "maxItems": 30,
  "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 = {
    "urls": [
        "https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/immoweb-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 = { "urls": ["https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/immoweb-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 '{
  "urls": [
    "https://www.immoweb.be/en/search/house/for-sale?countries=BE&page=1"
  ]
}' |
apify call kawsar/immoweb-property-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Immoweb Property Extractor",
        "description": "Immoweb property extractor that gathers property listings, prices, and locations from Immoweb.be. It lets real estate investors and analysts track housing market trends without clicking through pages manually.",
        "version": "0.0",
        "x-build-id": "sS1WfAgs7mAaBBQIF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~immoweb-property-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-immoweb-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~immoweb-property-extractor/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-immoweb-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~immoweb-property-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-immoweb-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",
                "required": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Immoweb URLs",
                        "type": "array",
                        "description": "Provide Immoweb.be search results URLs or direct listing URLs. The scraper will extract details for all matched listings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of property listings to extract details for per input URL.",
                        "default": 30
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds for fetching from the website.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
