# Marktplaats 2dehands AutoScout24 Car Listing Scraper (`market_flow/car-listing-scraper-apify`) Actor

Scrape used car listings from Marktplaats, 2dehands, and AutoScout24. Filter by brand, model, price, year, mileage, fuel, and location. Export JSON/CSV or use the Apify API — built for dealers, brokers, agencies, and market research in NL/BE.

- **URL**: https://apify.com/market\_flow/car-listing-scraper-apify.md
- **Developed by:** [Market Flow](https://apify.com/market_flow) (community)
- **Categories:** Lead generation, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
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?

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

## Marktplaats 2dehands AutoScout24 Car Listing Scraper

**Scrape car listings** from **Marktplaats**, **2dehands**, and **AutoScout24** with one Apify Actor. Extract **used car data** (price, year, mileage, fuel, seller, URL) from the Netherlands and Belgium — export JSON, CSV, Excel, or call it as a **car listings API** via Apify.

Ideal if you need a **Marktplaats scraper**, **2dehands scraper**, or **AutoScout24 scraper** for price monitoring, lead gen, market research, or dashboards. Built for **dealers, brokers, agencies, analysts, and startups** working with used-car data in the Netherlands and Belgium.

### What data can you extract from Marktplaats, 2dehands, and AutoScout24?

- Car ad title, price (EUR), year, mileage (km), fuel, gearbox
- Listing URL, city, country, seller name / ID
- Bidding (bieden) and boosted / advertised flags
- Optional detail-page fields (`enrich_*`) when enrich is on
- Structured output ready for Python, spreadsheets, or your own API

### What can this used car scraper do?

- Scrape **Marktplaats.nl**, **2dehands.be**, and **AutoScout24** car ads together or separately
- Filter by **brand**, **model**, **price**, **year**, **mileage**, **fuel**, **gearbox**, **doors**, **postcode + radius**
- Use brand/model dropdowns (or type a model name)
- Optionally **enrich** each listing from its detail page
- Optionally **split results by website** (Marktplaats / 2dehands / AutoScout24 datasets)
- Save **`scrape_total_time`** and per-site counts in **`SCRAPE_META`**
- Schedule runs, use webhooks, or integrate with Make, Zapier, and Google Sheets on Apify

### How to scrape Marktplaats car listings

1. Open this Actor in [Apify Console](https://console.apify.com/).
2. Set `sites` to Marktplaats (or add 2dehands / AutoScout24).
3. Choose brand, models, price, year, mileage, and other filters.
4. Optional: enable extra ad details and/or separate results by website.
5. Start the run and download the **car listing dataset** (JSON / CSV / Excel) or use the **Apify Dataset API**.

#### How to scrape 2dehands used cars

Same steps — include `2dehands` in `sites`. Great for Belgian used-car ads next to Marktplaats NL data.

#### How to scrape AutoScout24 car data

Include `autoscout24` in `sites` and set **AutoScout24 country** (e.g. Netherlands, Belgium, Germany). Combine with Marktplaats/2dehands in one run if you want.

### Input for this car listing scraper

Empty / omitted filters mean “any” (except where a default is noted).

| Field | Allowed values (enums) | Notes |
|--------|------------------------|--------|
| `action` | `scrape`, `list_brands`, `list_models` | `scrape` = car ads. The other two are **catalog calls** (brands/models lists only — not ads) |
| `catalog_source` | `lrp`, `as24`, `both` | Only for `list_brands` / `list_models`. `lrp` = Marktplaats & 2dehands, `as24` = AutoScout24, `both` = merge. Default: `lrp` |
| `sites` | `marktplaats`, `2dehands`, `autoscout24` | Multi-select (for scrape). Default: all three |
| `vehicle_type` | `cars`, `vans`, `trucks` | Default: `cars`. Also used by catalog calls |
| `brand_slug` | `""` (Any brand) or a slug from the dropdown, e.g. `volkswagen`, `toyota`, `bmw`, `opel`, `mercedes-benz`, `audi`, `ford`, `peugeot`, … (~90 brands) | For **scrape**: pick from dropdown. For **`list_models`**: required — which brand’s models to fetch. Prefer the **List brands** catalog call if you need the full live list of slugs |
| `models` | Model names, e.g. `Golf`, `Corolla`, `Agila` | For **scrape** only. Multi-select or type your own. Empty = any model. Prefer **List models** catalog call to discover valid names for a brand |
| `body_type_ids` | `Hatchback`, `SUV`, `Stationwagon`, `Sedan`, `MPV`, `Cabriolet`, `Coupe`, `Other` | Multi-select. Applied on Marktplaats, 2dehands, and AutoScout24 |
| `fuel_type_ids` | `Petrol`, `Diesel`, `Electric`, `Hybrid Petrol`, `Hybrid Diesel`, `LPG`, `CNG`, `Hydrogen`, `Other` | Multi-select |
| `transmission_id` | `Any`, `Automatic`, `Manual` | Default: `Any` |
| `doors` | `Any`, `2-or-3`, `4-or-5`, `6-plus` | Default: `Any` |
| `price_min_eur` | Integer (EUR), e.g. `1000` | Optional minimum price |
| `price_max_eur` | Integer (EUR), e.g. `25000` | Optional maximum price |
| `year_min` | Integer year, e.g. `2015` | Optional |
| `year_max` | Integer year, e.g. `2020` | Optional |
| `mileage_min_km` | Integer km, e.g. `0` | Optional |
| `mileage_max_km` | Integer km, e.g. `200000` | Optional |
| `as24_country_code` | `Netherlands`, `Belgium`, `Germany`, `France`, `Italy`, `Luxembourg`, `Spain`, `Austria`, `Europe` | AutoScout24 only. Default: `Netherlands` |
| `zip` | Postcode string, e.g. `1012`, `2000` | Use with `radius_km` on Marktplaats/2dehands |
| `radius_km` | Integer km (1–400), e.g. `50`, `100` | Distance in km around `zip`. Typical: 10, 20, 50, 100, 150, 200, 250, 300, 400 |
| `max_pages` | Integer ≥ `1` (default `5`) | Result pages per site (scrape) |
| `enrich_output` | `true`, `false` | Default `false`. Extra detail fields; **extra fee** per success |
| `split_output_by_site` | `true`, `false` | Default `false`. Separate datasets per website |
| `today_only` | `true`, `false` | Default `false`. **Not used yet** |

#### Brand & model catalog calls (`list_brands` / `list_models`)

Besides the scrape form dropdowns, you can run **extra Actor calls** that only return catalog rows (no car ads). Useful if you build your own UI or need the full live brand/model list.

| Action | What you get | Required input |
|--------|----------------|----------------|
| `list_brands` | Dataset rows with `type: "brand"`, `brand_slug`, `label`, `source` | `vehicle_type`, `catalog_source` |
| `list_models` | Dataset rows with `type: "model"`, `brand_slug`, `label`, `id`, `source` | `brand_slug`, `vehicle_type`, `catalog_source` |

**List brands example**

```json
{
  "action": "list_brands",
  "vehicle_type": "cars",
  "catalog_source": "lrp"
}
```

**List models example** (after you know the brand slug)

```json
{
  "action": "list_models",
  "brand_slug": "volkswagen",
  "vehicle_type": "cars",
  "catalog_source": "both"
}
```

Typical flow: run **List brands** → copy a `brand_slug` → run **List models** → copy model `label` values into `models` → run **`scrape`**.

#### Car scraper input example (JSON)

```json
{
  "action": "scrape",
  "sites": ["marktplaats", "2dehands", "autoscout24"],
  "vehicle_type": "cars",
  "brand_slug": "volkswagen",
  "models": ["Golf"],
  "price_min_eur": 1000,
  "price_max_eur": 25000,
  "year_min": 2015,
  "max_pages": 1,
  "enrich_output": false,
  "split_output_by_site": false
}
```

### Output: Marktplaats / 2dehands / AutoScout24 listing data

Every result is one **car listing** in the default Apify Dataset. Turn on **Separate results by website** to also fill alias datasets: `marktplaats`, `twodehands` (2dehands), `autoscout24`.

**`SCRAPE_META`** (key-value store) includes `scrape_total_time`, `listing_count`, and `by_site`.

#### Car listing fields

| Field | Description |
|--------|-------------|
| `site` | marktplaats, 2dehands, or autoscout24 |
| `item_id` | Listing ID |
| `title` | Ad title |
| `listing_url` | URL of the ad |
| `price_eur` | Price in EUR |
| `is_bidding` | Bidding / bieden |
| `is_advertised_or_boosted` | Promoted / boosted ad |
| `construction_year` | Year |
| `mileage_km` | Odometer (km) |
| `fuel` / `transmission` | Fuel and gearbox |
| `city` / `country` | Location |
| `seller_name` / `seller_id` | Seller when available |
| `enrich_*` | Extra fields when enrich is on |

#### Car listing output example

```json
{
  "site": "marktplaats",
  "item_id": "m1234567890",
  "title": "Volkswagen Golf 1.4 TSI",
  "listing_url": "https://www.marktplaats.nl/v/...",
  "price_eur": 8950.0,
  "is_bidding": false,
  "is_advertised_or_boosted": true,
  "construction_year": 2018,
  "mileage_km": 112000,
  "fuel": "Petrol",
  "transmission": "Manual",
  "city": "Amsterdam",
  "country": "NL"
}
```

#### Export used car data from Apify

- Output tab → All listings / overview
- Download JSON, CSV, Excel, or HTML
- Dataset API / Apify client (Python, JS) for automation

### How much does it cost to scrape Marktplaats or AutoScout24?

Pricing is set in Apify Store (pay per event). Typical model:

- **Per listing** in the dataset (normal scrape)
- **Extra per enriched listing** when you enable **Add extra details from each ad** (event name: `listing-enriched`)

Enrich opens each ad’s detail page, so it uses more time and proxy traffic — that is why it is billed separately. Start with `max_pages: 1` and enrich **off** to estimate cost, then scale up.

### Why use Apify for Marktplaats and AutoScout24 scraping?

- Run as a **Marktplaats API-style** data pipeline without maintaining servers
- **Schedule** daily used-car scrapes in NL/BE
- **Integrate** with Sheets, webhooks, Make, Zapier
- Store and query results in Apify **Datasets**

### Who can use this car listing scraper?

This Marktplaats / 2dehands / AutoScout24 scraper fits many businesses and teams that need fresh used-car data:

| Business / team | Typical use |
|-----------------|-------------|
| **Used car dealers** | Watch competitor stock and pricing on Marktplaats & AutoScout24 |
| **Car brokers & traders** | Find underpriced ads by brand, model, year, and mileage |
| **Dealership groups** | Daily multi-site inventory and market scans (NL/BE) |
| **Leasing & fleet companies** | Track residual values and similar cars for sale |
| **Insurance & claims** | Compare market prices for a make/model/year |
| **Automotive marketplaces** | Aggregate listings into your own product feed |
| **Price comparison / data startups** | Build a used-cars Netherlands & Belgium database |
| **Marketing & lead-gen agencies** | Spot new ads and push leads to CRM |
| **Export / import traders** | Screen AutoScout24 and local classifieds for stock |
| **Consultants & analysts** | One-off or scheduled market reports |
| **Software / AI product teams** | Feed models and apps via the Apify API |
| **Indie developers & researchers** | Export JSON/CSV without building a scraper stack |

If your work depends on **used car listings**, **pricing**, or **availability** in NL/BE (and AutoScout24 countries), you can run this Actor on a schedule and plug results into Sheets, webhooks, or your own API.

### Use cases

- Track **Volkswagen Golf** / **Toyota** / **BMW** prices on Marktplaats and 2dehands
- Compare **AutoScout24** vs Marktplaats for the same model
- Build a **used cars Netherlands / Belgium** database for a dealer or SaaS product
- Alert sales teams when new ads appear under a max price or mileage
- Support valuation, sourcing, and competitor monitoring workflows

### FAQ

#### Is there a Marktplaats API for car listings?

Not an official public API for this use case. This Actor scrapes listing search/detail pages and returns structured car data through Apify (JSON/CSV/API).

#### Can I scrape only Marktplaats?

Yes — set `sites` to `["marktplaats"]`.

#### Can I scrape only AutoScout24?

Yes — set `sites` to `["autoscout24"]` and choose the country.

#### Can I scrape 2dehands Belgium cars?

Yes — include `2dehands` in `sites`.

#### Does this work with Python?

Yes. Start the Actor from the Apify API or Python client, then read the dataset items as JSON.

#### What about vans or trucks?

Set `vehicle_type` to `vans` or `trucks` when you need those categories.

#### Does enrich cost extra?

Yes. **Add extra details from each ad** bills an extra **`listing-enriched`** event for each listing that was successfully enriched, on top of the normal per-listing price.

#### Do I need to install or deploy anything?

No. Open the Actor in Apify Console, set filters, and click **Start**. Results appear in the Output tab and dataset — ready to download or pull via the Apify API.

# Actor input Schema

## `action` (type: `string`):

Find car listings, or run a catalog call to list brands / models (helpful before you scrape).

## `catalog_source` (type: `string`):

Only for List brands / List models. Where to load names from.

## `sites` (type: `array`):

Which sites to search. Marktplaats is Netherlands, 2dehands is Belgium, AutoScout24 covers several countries.

## `vehicle_type` (type: `string`):

Cars, vans, or trucks.

## `brand_slug` (type: `string`):

Pick a car brand, or Any brand.

## `models` (type: `array`):

Pick one or more models. You can also type a model name if it is missing. Leave empty for any model.

## `body_type_ids` (type: `array`):

Body styles to include. Works on Marktplaats, 2dehands, and AutoScout24. You can pick more than one.

## `fuel_type_ids` (type: `array`):

Fuel types to include. You can pick more than one.

## `transmission_id` (type: `string`):

Automatic, manual, or any gearbox.

## `doors` (type: `string`):

How many doors the car should have.

## `price_min_eur` (type: `integer`):

Only show cars at this price or higher.

## `price_max_eur` (type: `integer`):

Only show cars at this price or lower.

## `year_min` (type: `integer`):

Oldest year you want (for example 2015).

## `year_max` (type: `integer`):

Newest year you want (for example 2020).

## `mileage_min_km` (type: `integer`):

Only show cars with at least this many kilometres.

## `mileage_max_km` (type: `integer`):

Only show cars with at most this many kilometres.

## `as24_country_code` (type: `string`):

Country for AutoScout24 only. Does not change Marktplaats or 2dehands.

## `zip` (type: `string`):

Search near this postcode. On Marktplaats and 2dehands you also need a distance.

## `radius_km` (type: `integer`):

How far from the postcode to search. Typical values: 10, 20, 50, 100, 150, 200, 250, 300, 400.

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

More pages means more results, but the run takes longer. Usually 1–5 is enough.

## `enrich_output` (type: `boolean`):

Opens each listing’s detail page for more info (full description, seller type, doors, and similar). Makes the run slower and costs extra per enriched listing (pay-per-event: listing-enriched).

## `split_output_by_site` (type: `boolean`):

Also save Marktplaats, 2dehands, and AutoScout24 results in their own groups. Useful if you want to download one site at a time.

## `today_only` (type: `boolean`):

Not available yet. Turning this on does nothing for now.

## Actor input object example

```json
{
  "action": "scrape",
  "catalog_source": "lrp",
  "sites": [
    "marktplaats",
    "2dehands",
    "autoscout24"
  ],
  "vehicle_type": "cars",
  "brand_slug": "",
  "transmission_id": "Any",
  "doors": "Any",
  "as24_country_code": "Netherlands",
  "max_pages": 5,
  "enrich_output": false,
  "split_output_by_site": false,
  "today_only": false
}
```

# Actor output Schema

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

Combined default dataset (all sites).

## `listingsOverview` (type: `string`):

Table view of scraped listings.

## `marktplaats` (type: `string`):

Filled when Split results by website is enabled. Alias dataset marktplaats.

## `twodehands` (type: `string`):

Filled when Split results by website is enabled. Alias twodehands (2dehands listings).

## `autoscout24` (type: `string`):

Filled when Split results by website is enabled. Alias dataset autoscout24.

## `scrapeMeta` (type: `string`):

KV SCRAPE\_META: scrape\_total\_time (seconds), listing\_count, by\_site, enrich\_output, split\_output\_by\_site, start\_urls, filters.

## `catalog` (type: `string`):

Table view for list\_brands / list\_models results.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("market_flow/car-listing-scraper-apify").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("market_flow/car-listing-scraper-apify").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 '{}' |
apify call market_flow/car-listing-scraper-apify --silent --output-dataset

```

## MCP server setup

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

```

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/cxW9saGnSZ0MWnQd2/builds/8iBOPz61x3WG80UEL/openapi.json