# AutoScout24 Scraper — EU Cars, Dealer Leads & Monitor (MCP) (`amygraphics/autoscout24-eu-scraper`) Actor

AutoScout24 cars from 8 EU markets (DE AT IT ES FR BE NL LU): full specs, photos + dealer phone numbers, and a built-in monitor for new cars, price drops & removed ads. Beats the 4 000-per-query cap. $0.4 per 1 000 cars.

- **URL**: https://apify.com/amygraphics/autoscout24-eu-scraper.md
- **Developed by:** [Zakaria el bouami](https://apify.com/amygraphics) (community)
- **Categories:** E-commerce, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## AutoScout24 EU Cars Scraper — Dealer Phones, Specs & Price Monitor (MCP)

Scrape **AutoScout24** — Europe's largest used-car marketplace, **over 2 million live cars** — across
**8 markets: 🇩🇪 DE · 🇦🇹 AT · 🇮🇹 IT · 🇪🇸 ES · 🇫🇷 FR · 🇧🇪 BE · 🇳🇱 NL · 🇱🇺 LU**.
No browser, no proxies, no AutoScout24 account: one clean row per car.

**Find → Compare → Monitor → Alert.** Point it at a search once and you get three things buyers
actually pay for: the **cars** (full market, not the first 4 000), the **dealers behind them**
(company, contact person, phone numbers), and a **daily delta** — new cars, price drops, removals —
that you can push into Sheets, Slack or your own system through the Apify platform.

Most AutoScout24 datasets stop at price + mileage. This Actor is built for people who need the
**money data**:

| What you get | Why it matters |
|---|---|
| **Dealer phone numbers** (office + mobile), company name, contact person, dealer page | Lead generation for financing, insurance, export, parts — no second call needed |
| **Monitor mode**: `new`, `price_dropped`, `price_increased`, `closed` (+ `oldPrice`, `priceDelta`, `priceDeltaPct`) | Tells you *what changed since yesterday* — the price drop is the buy signal. Search **and** monitoring in one Actor (most rivals make you run a second, separate tool) |
| Full technical block | mileage, first registration, power, fuel, gearbox, body type, seats, doors, colour, CO₂, damage flag |
| Full market coverage | AutoScout24 silently caps **every** search at 4 000 cars; this Actor detects it and splits by price → registration year → mileage |
| Optional detail enrichment | seller's full ad text, exact GPS, **WhatsApp** number, HSN/TSN codes, warranty |
| Up to 25 photos per car | direct 800×600 URLs for listings, catalogues, galleries |

### Why this Actor (honest comparison)

AutoScout24 attracted a lot of Actors in 2026 — several search scrapers, and a few small dedicated
price-monitor tools. Here is what makes this one different, without the marketing varnish:

- **Search + monitor in one product.** Competitor monitors usually cover only a narrow slice (one
  search, or a single listing URL) and charge per price-drop event (up to **$0.01 per alert
  elsewhere** vs $0.0004 per car here).
- **Whole-market coverage, not the first 4 000.** The split logic (price → year → mileage) is what
  turns "all Renault in France" from a truncated sample into the real inventory — with one scope per
  split written in the run log so you can audit it.
- **Dealer phones come with the search** (fixed + mobile, company, contact). No second pass, no
  per-listing lookup tool.
- **The price tag**: **$0.40 / 1 000 cars**, platform usage included — among the cheapest in the
  Store (matches are at $0.49–$3 / 1 000, and $0.003 per listing elsewhere is 7.5× our rate).

### Hard problems this Actor solves

1. **The 4 000-cars-per-query cap.** Ask for "every Renault in France" and AutoScout24 quietly returns
   only the first 4 000 — no error, no warning. This Actor notices (`numberOfResults` > 4 000) and
   **splits the query recursively: price bands → first-registration years → mileage bands**, then merges
   by unique car id. Your filters are respected inside every band (a 10 000–15 000 € search never
   returns a 900 € car). Each split is written to the run log.
2. **Filters that actually work.** Verified one by one against the live site: price, mileage,
   registration year, power, fuel type, private/dealer seller. Transmission is *not* supported by the
   portal's URL — so the Actor filters automatic/manual itself. Countries: 8 (Switzerland's
   autoscout24.ch is a separate, bot-protected site and is not covered — promised here, so you know).
3. **Honest monitoring.** State lives in an Apify key-value store, one history per search scope.
   Price movements are classified with delta and %; ads that left the marketplace are flagged
   `closed` **only when the scan was complete and error-free** — never because a request failed or a
   scope was truncated.

### Quick examples

- **Dealer leads, Germany, vans under 20 000 €** — `countries: DE`, `make: Volkswagen`, `priceMax: 20000`,
  `sellerType: dealer` → every row carries the dealer's phone numbers and address.
- **Cheap cars for export, Italy/Luxembourg** — `countries: IT, LU`, `priceMax: 5000`, `sort: price_asc`.
- **Daily price-drop watch** — `mode: monitor` on a schedule (e.g. BMW 3er under 20 000 € in DE):
  you get only new cars and price cuts, with `oldPrice` → `price` and the percentage.
- **Electric cars, all 8 markets** — `fuel: electric`, `yearMin: 2020` → supply and prices per country.

### Input tips

- `mode`: **search** = full extraction, **monitor** = only the delta since the previous run.
- `countries`: multi-select; combine as many as you need in one run.
- `make` / `model`: spelled as AutoScout24 does (`BMW`, `Mercedes-Benz`, `3er`, `golf`, `clio`, `500`).
- `maxResults`: global cap on rows returned (and billed) — the run stops cleanly when reached.
- `autoSplit`: keep it on; it is what makes large scopes complete.
- `fetchDetails`: adds the ad text, GPS, WhatsApp and HSN/TSN (one extra request per car).
- Monitor mode always sorts newest-first and covers the newest 4 000 cars per scope; narrow the
  filters (make/model/price) to monitor a wider window cheaply.

### Automation, MCP & scheduling

- **Schedule**: run `monitor` daily (or hourly). Unchanged cars are not returned and not charged.
- **Webhooks / integrations**: pipe the dataset to Google Sheets, Airtable, Slack, n8n, Zapier or your
  own API through the Apify platform — one click, no code.
- **MCP-ready**: exposed through Apify's Model Context Protocol server as
  `amygraphics/autoscout24-eu-scraper`, so AI agents (Claude, Cursor, VS Code, custom agents) can
  discover and run it, and pay autonomously — this Actor is **whitelisted for agentic payments**
  (x402 / AGI prepaid token), no Apify account required.

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=amygraphics/autoscout24-eu-scraper" }
  }
}
```

Ask it things like:

- *"Find BMW X5s in Germany under €30,000 with less than 100,000 km, newest first."*
- *"Give me every private-seller car under €5,000 in Italy and Luxembourg, with the seller's phone."*
- *"Set this up as a daily monitor and show me only cars whose price dropped."*

Monitoring answers come from the Actor's own run history (its key-value store), so schedule it —
an agent calling it once gets the current market, a scheduled actor gives it the deltas.

### Pricing

Pay-per-event: `$0.001` start + **`$0.0004` per car** (`car-extracted`) — **$0.40 per 1 000 cars**,
the cheapest AutoScout24 data in the Store. Monitor mode only charges for new, changed and closed cars.

***

### Notes & fair use

This Actor collects publicly available listing data from AutoScout24 search and detail pages. Dealer
phones and company details are **business contact data published by the dealers themselves** on their
own ads — but if you use them for outreach, that outreach is your responsibility: follow your local
e-mail/phone marketing rules (EU GDPR + ePrivacy for individual contacts), AutoScout24's terms, and
keep request rates polite (the Actor throttles itself and retries `429`/`5xx` with backoff).

***

### Auf Deutsch (kurz)

**AutoScout24 Scraper für 8 Märkte** (DE · AT · IT · ES · FR · BE · NL · LU): Preis, Kilometer,
Erstzulassung, Leistung, Kraftstoff, Getriebe, Ausstattung, Fotos — **plus die Telefonnummern des
Händlers** (Festnetz + Mobil), Firmenname und Ansprechpartner, direkt aus der Suche. **Monitor-Modus**:
nur neue Angebote, **Preissenkungen** (alt/neu + %) und gelöschte Anzeigen. Jede Suche wird bei
AutoScout24 nach 4 000 Autos stillschweigend abgeschnitten — dieser Actor erkennt das und teilt die
Suche automatisch nach Preis → Erstzulassung → Kilometer auf. **0,40 $ pro 1 000 Autos.**

### En français (court)

**Scraper AutoScout24 pour 8 marchés** (DE · AT · IT · ES · FR · BE · NL · LU) : prix, kilométrage,
première mise en circulation, puissance, carburant, boîte, carrosserie, photos — **et les numéros de
téléphone du vendeur** (fixe + mobile), la société et le contact, directement depuis la recherche.
**Mode monitor** : nouvelles annonces, **baisses de prix** (ancien/nouveau + %) et annonces retirées.
Chaque recherche est silencieusement plafonnée à 4 000 voitures par AutoScout24 — cet Actor le détecte
et découpe automatiquement par prix → année → kilométrage. **0,40 $ / 1 000 voitures.**

***

#### Keywords

AutoScout24 scraper · AutoScout24 API alternative · used cars Europe · car listings data · dealer
leads · dealer phone numbers · car price monitor · price drop tracker · Germany cars · Austria cars ·
Italy cars · Spain cars · France cars · export cars · car market data · automotive MCP server · AI
agent car data.

# Actor input Schema

## `mode` (type: `string`):

search = extract every matching car. monitor = compare with the previous run and return only what is new, changed (price drops included), or gone — perfect for a daily schedule.

## `countries` (type: `array`):

One or more AutoScout24 markets. Switzerland (autoscout24.ch) is a separate site and is not covered.

## `make` (type: `string`):

Optional. Car brand exactly as AutoScout24 spells it, e.g. BMW, Mercedes-Benz, Volkswagen, Renault, Fiat.

## `model` (type: `string`):

Optional. Needs a make. AutoScout24 model codes: 3er, golf, a4, clio, 500, punto…

## `priceMin` (type: `integer`):

Optional. Minimum price.

## `priceMax` (type: `integer`):

Optional. Maximum price — also the first splitting dimension when a search is capped.

## `kmMin` (type: `integer`):

Optional.

## `kmMax` (type: `integer`):

Optional.

## `yearMin` (type: `integer`):

Optional, e.g. 2018.

## `yearMax` (type: `integer`):

Optional, e.g. 2023.

## `powerMin` (type: `integer`):

Optional.

## `powerMax` (type: `integer`):

Optional.

## `fuel` (type: `array`):

Optional. Leave empty for all fuels.

## `sellerType` (type: `string`):

Dealers have company name + phone numbers. Private sellers are often cheaper.

## `transmission` (type: `string`):

AutoScout24 ignores this filter in the URL, so the Actor applies it itself to the collected cars.

## `sort` (type: `string`):

Order of the search (monitor mode always uses 'newest').

## `maxResults` (type: `integer`):

Global cap on rows returned (and charged).

## `autoSplit` (type: `boolean`):

Recommended. AutoScout24 cuts every search at 4 000 cars without warning; the Actor splits such searches by price → first-registration year → mileage and merges the results.

## `fetchDetails` (type: `boolean`):

Adds the seller's full description, exact coordinates, WhatsApp number and the HSN/TSN codes. Dealer phones, specs and photos already come without it.

## `includeImages` (type: `boolean`):

Up to 25 high-resolution photo URLs per car (800×600).

## `onlyChanges` (type: `boolean`):

Monitor mode only. Unchanged cars are not returned and not charged.

## `detectClosed` (type: `boolean`):

Monitor mode only. Cars that disappeared from the marketplace are returned once with changeType='closed', then forgotten. Only when the scan was complete and error-free.

## `stateKey` (type: `string`):

Leave empty: derived from your search scope, so each search keeps its own history.

## Actor input object example

```json
{
  "mode": "search",
  "countries": [
    "DE"
  ],
  "make": "",
  "model": "",
  "priceMin": null,
  "priceMax": null,
  "kmMin": null,
  "kmMax": null,
  "yearMin": null,
  "yearMax": null,
  "powerMin": null,
  "powerMax": null,
  "fuel": [],
  "sellerType": "any",
  "transmission": "any",
  "sort": "newest",
  "maxResults": 20,
  "autoSplit": true,
  "fetchDetails": false,
  "includeImages": true,
  "onlyChanges": true,
  "detectClosed": true,
  "stateKey": ""
}
```

# Actor output Schema

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

No description

# 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 = {
    "mode": "search",
    "countries": [
        "DE"
    ],
    "make": "",
    "model": "",
    "fuel": [],
    "sellerType": "any",
    "transmission": "any",
    "sort": "newest",
    "maxResults": 20,
    "autoSplit": true,
    "fetchDetails": false,
    "includeImages": true,
    "onlyChanges": true,
    "detectClosed": true,
    "stateKey": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("amygraphics/autoscout24-eu-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 = {
    "mode": "search",
    "countries": ["DE"],
    "make": "",
    "model": "",
    "fuel": [],
    "sellerType": "any",
    "transmission": "any",
    "sort": "newest",
    "maxResults": 20,
    "autoSplit": True,
    "fetchDetails": False,
    "includeImages": True,
    "onlyChanges": True,
    "detectClosed": True,
    "stateKey": "",
}

# Run the Actor and wait for it to finish
run = client.actor("amygraphics/autoscout24-eu-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 '{
  "mode": "search",
  "countries": [
    "DE"
  ],
  "make": "",
  "model": "",
  "fuel": [],
  "sellerType": "any",
  "transmission": "any",
  "sort": "newest",
  "maxResults": 20,
  "autoSplit": true,
  "fetchDetails": false,
  "includeImages": true,
  "onlyChanges": true,
  "detectClosed": true,
  "stateKey": ""
}' |
apify call amygraphics/autoscout24-eu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,amygraphics/autoscout24-eu-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/6jkAc6Xowk6chRrVz/builds/qfGh1PXHFXIq7TxYz/openapi.json