# 2dehands.be Car Scraper (`rastriq/2dehands-scraper`) Actor

Scrape car listings from 2dehands.be, the Belgian classifieds site (sister of Marktplaats): make, model, year, mileage, price, fuel, gearbox, city, dealer flag, photo and URL. Filter by brand or keyword. No residential proxy needed.

- **URL**: https://apify.com/rastriq/2dehands-scraper.md
- **Developed by:** [Rastriq — Structured data from the world](https://apify.com/rastriq) (community)
- **Categories:** E-commerce, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 car listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 2dehands.be Car Scraper

**2dehands.be Car Scraper** extracts used-car listings from [2dehands.be](https://www.2dehands.be/l/auto-s/), the Belgian classifieds site (known as 2ememain.be in French). You get make, model, year, mileage, price, fuel, gearbox, city, dealer or private seller, photo and listing URL as clean JSON, CSV or Excel, in seconds and without a residential proxy.

### 🚗 What is 2dehands.be Car Scraper?

2dehands.be is one of the biggest places to buy and sell used cars in Belgium, with around 95,000 car listings online at any time. It runs on the same platform as Marktplaats.nl in the Netherlands. The site has no public API, so tracking prices or stock across thousands of listings means copying them by hand.

2dehands.be Car Scraper does that for you. It reads the same search results you see in the **Auto's** section, page by page, and turns every listing into a structured record. You can scrape all cars, newest first, or narrow the search to a brand or keywords such as `BMW`, `Tesla Model 3` or `Volkswagen Golf`.

Use this 2dehands scraper to:

- 📈 **Track used-car prices in Belgium** by brand, model, year and mileage.
- 🏪 **Monitor dealer stock** and new listings for lead generation or competitor watch.
- 🔍 **Find underpriced cars** by comparing asking price against year and mileage.
- 📊 **Feed market research and valuation models** with fresh Belgian car data.
- 🔁 **Build alerts**: schedule the actor every hour or day and compare runs.

### 📋 What data does 2dehands.be Car Scraper extract?

| Field | Description |
|---|---|
| 🆔 `id` | 2dehands listing ID |
| 📝 `title` | Listing title, as written by the seller (Dutch or French) |
| 🏷️ `make` | Car brand, e.g. `Audi`, `BMW`, `Mercedes-Benz` |
| 🚙 `model` | Model, e.g. `A3`, `X5`, `Master` |
| 📅 `year` | Construction year |
| 🛣️ `km` | Mileage in kilometres |
| ⚡ `hp` | Power in metric hp (PS), only when the listing shows it in the results (rare) |
| 💶 `price` | Asking price (or minimum bid) in EUR |
| 💱 `currency` | Always `EUR` |
| ⛽ `fuel_type` | Fuel, in Dutch: `Benzine`, `Diesel`, `Elektrisch`, `Hybride…` |
| ⚙️ `gearbox` | `Automaat` or `Handgeschakeld` |
| 📍 `city` | City or town of the listing |
| 🏢 `is_professional` | `true` dealer, `false` private seller, `null` when the results do not say |
| 🔗 `url` | Link to the listing page |
| 🖼️ `img_url` | Main photo |
| 🌐 `source`, 🕒 `scraped_at` | `2dehands.be` and the UTC time of extraction |

`region` is always `null` (the results only give the city). The scraper reads search results only: it does not open each listing, so it does not return the full description, equipment list, seller name or phone number.

**Data completeness** (measured on 60 listings, November 2026): `make` is filled on about 92 % of listings (the rest are mostly trucks whose title does not start with a brand), `model`, `year` and `km` on about 90 %, `fuel_type` on 100 %. `is_professional` is known for about a third of listings; for the rest 2dehands does not say in its search results.

### ▶️ How to use 2dehands.be Car Scraper

1. Click **Try for free** (or **Start**) on this page. You need a free Apify account.
2. Optionally type a brand or keywords in **Brand or keyword**. Leave it empty for all cars.
3. Set **Max pages**. Each page holds 30 cars: 1 page for a test, 10 pages for 300 cars.
4. Click **Start** and wait a few seconds. One page takes about 2 seconds.
5. Open the **Output** tab, then download the data as JSON, CSV, Excel or HTML, or read it through the Apify API.

To keep the data fresh, create a **Schedule** in Apify Console and run 2dehands.be Car Scraper every hour or every day.

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `brand` | string | empty | Brand or search words, like the search box on 2dehands.be |
| `max_pages` | integer | 3 | Pages to scrape (30 cars each), from 1 to 167 |
| `proxyConfiguration` | object | Apify Proxy (datacenter) | Change only if you get blocked |

#### Input example

```json
{
    "brand": "BMW",
    "max_pages": 1,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

### 📦 Output example

One record, taken from a real run (November 2026):

```json
{
    "id": "m2449700184",
    "title": "BMW X5 xDrive 40e",
    "make": "BMW",
    "model": "X5",
    "year": 2017,
    "km": 175000,
    "hp": null,
    "price": 21200.0,
    "currency": "EUR",
    "fuel_type": "Hybride Elektrisch/Benzine",
    "gearbox": "Automaat",
    "city": "Ukkel",
    "region": null,
    "is_professional": null,
    "url": "https://www.2dehands.be/v/auto-s/bmw/m2449700184-bmw-x5-xdrive-40e",
    "img_url": "https://images.2dehands.com/api/v1/hz-twh-pro-listing/images/a471ad47-0036-4cc6-ba81-337bdd188170?rule=ecg_mp_eps$_82.jpg",
    "source": "2dehands.be",
    "scraped_at": "2026-11-14T08:33:03.004580+00:00"
}
```

In Apify Console, the **Overview** view shows the main columns (title, make, model, year, km, price, fuel, gearbox, city, dealer and link) and **All fields** adds the photo, ID and timestamp.

### 💰 How much does it cost to scrape 2dehands.be?

2dehands.be Car Scraper uses **pay-per-event** pricing: you pay **$1.50 per 1,000 car listings**, plus a tiny start fee of **$0.005** per run. There is no monthly rental, and the Apify platform usage is included in the price.

- **100 listings**: about $0.16
- **1,000 listings**: about $1.51
- **5,000 listings** (a full search): about $7.51

With the $5 of free monthly credit on the Apify Free plan you can scrape more than 3,000 listings a month at no cost.

> 💡 **Tip**: start with `max_pages: 1` to see the data, then scale up.

### ⚠️ Limits

- **Up to about 5,000 listings per search.** 2dehands serves at most 167 result pages of 30 cars. To go further, split your work into several searches, e.g. one per brand.
- **Search results only.** Fields that appear only on the listing page (full description, options, owner history, seller contact) are not extracted.
- **Dutch labels.** Fuel and gearbox are returned as 2dehands shows them, in Dutch.
- The `brand` input is a free-text search, so `BMW` can also match a listing that mentions BMW in its text.

### 🔗 Related Actors

2dehands.be Car Scraper is part of the [Rastriq](https://apify.com/rastriq) family of car marketplace scrapers for Europe, with actors for Marktplaats.nl, Willhaben, Kleinanzeigen, Leboncoin and more, all with the same output fields so you can merge countries in one table.

### ❓ FAQ

#### Is it legal to scrape 2dehands.be?

2dehands.be Car Scraper only collects data that anyone can see on the public search pages, and it does not collect seller names or phone numbers. You are responsible for how you use the data: check the 2dehands.be terms of use and the GDPR before using it, especially for commercial purposes.

#### Do I need a proxy?

No residential proxy is needed. The default Apify Proxy (datacenter) works. If your runs start returning HTTP 403, switch the proxy to the **RESIDENTIAL** group with country **BE**; Apify then bills the residential traffic per GB.

#### How fresh is the data?

Every run reads 2dehands.be live, so you get the listings online at that moment. The first page is sorted the way the site sorts it, which puts promoted listings first.

#### Can I get the data through an API?

Yes. Run 2dehands.be Car Scraper through the Apify API or one of the Apify clients for Python and JavaScript, and read the results from the run's dataset. You can also connect it to Make, Zapier, Google Sheets or a webhook.

#### Why is `is_professional` sometimes null?

2dehands only says whether the seller is a business (*Bedrijf*) or private (*Particulier*) on some listings in its search results. When it does not, the scraper leaves the field empty rather than guessing.

#### Something does not work. What do I do?

Open an issue on the **Issues** tab with your run ID. We read every report.

# Changelog

This Actor's version history is a separate document: https://apify.com/rastriq/2dehands-scraper/changelog.md

# Actor input Schema

## `brand` (type: `string`):

Optional. A brand or any search words, e.g. <code>BMW</code>, <code>Tesla Model 3</code> or <code>Volkswagen Golf</code>. Works like the search box on 2dehands.be. Leave empty to get all cars.

## `max_pages` (type: `integer`):

How many result pages to scrape. Each page returns <b>30 cars</b>, so 10 pages ≈ 300 listings. The site stops at 167 pages per search. Start with 1 page for a test run.

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

Apify Proxy (datacenter) is used by default and is enough for 2dehands.be. If you ever see HTTP 403, try the <b>RESIDENTIAL</b> group with country <b>BE</b> (residential traffic is billed by Apify per GB).

## Actor input object example

```json
{
  "brand": "BMW",
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped listings in the default dataset.

# 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 = {
    "brand": "BMW",
    "max_pages": 1,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rastriq/2dehands-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 = {
    "brand": "BMW",
    "max_pages": 1,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("rastriq/2dehands-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 '{
  "brand": "BMW",
  "max_pages": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call rastriq/2dehands-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rastriq/2dehands-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/Xc8dizfo0HgbdPc5e/builds/7oeJWPlSehoPYRsWd/openapi.json
