# AutoScout24 Scraper - Cars, Prices & Dealer Leads (`scrapesage/autoscout24-scraper`) Actor

Scrape AutoScout24, Europe's largest car marketplace. Get full vehicle specs, real prices, mileage, fuel, emissions & photos across 8 countries. Filter by make/model/price/year/fuel. Full car details + dealer B2B leads with phone, website & ratings. Price-drop & new-listing monitoring, no start fee.

- **URL**: https://apify.com/scrapesage/autoscout24-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.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/platform/actors/running/actors-in-store#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

## AutoScout24 Scraper — Cars, Prices & Dealer Leads (Specs, Emissions & Contacts)

Extract **complete AutoScout24 car data** — Europe's largest car marketplace — with the fields other scrapers leave empty: **real prices, full mileage & registration, every vehicle spec, fuel consumption & CO₂ emissions, accident & service history, and the selling dealer's phone, website & address**. Optionally turn every dealer into a **ready-to-contact B2B lead** with ratings, opening hours, VAT, and emails crawled from their own website.

No login, no API key, no browser — fast JSON extraction across **8 countries** (Germany, Austria, Belgium, Spain, France, Italy, Luxembourg, Netherlands).

### Why this AutoScout24 scraper?

Most AutoScout24 scrapers return only the search-card basics and charge a start fee on top. This actor reads AutoScout24's own server-rendered data and ships the **richest dataset in the category — with no start fee**:

| Data | Typical scrapers | This actor |
|---|---|---|
| Make / model / variant / price / mileage | ✅ | ✅ |
| First registration, fuel, transmission, power (kW + hp) | partial | ✅ |
| Full equipment list, doors/seats, colours, gears, drivetrain | ❌ | ✅ |
| Fuel consumption, **CO₂ emissions & emission class** | ❌ | ✅ |
| **Accident history, full-service history, previous owners** | ❌ | ✅ |
| Dealer **phone** on every listing | partial | ✅ |
| Dealer **website, email, VAT, opening hours, ratings** | ❌ | ✅ leads mode |
| Lead score (0–100) per dealer | ❌ | ✅ |
| Price-drop + new-listing **monitoring** | partial | ✅ |
| Start fee | 💸 usually | **none** |

### Use cases

- **Dealer & market intelligence** — track pricing, mileage-vs-price, and inventory depth by make, model, country, and fuel type. Spot under- and over-priced cars and `superDeal` flags in real time.
- **Lead generation** — car dealers are active B2B buyers of DMS/CRM software, financing, warranty, logistics, parts, and advertising. Get their `phone`, `website`, `email`, `vatId`, ratings and a `leadScore` to reach them directly.
- **Price & inventory monitoring** — run on a schedule with monitoring mode to capture only **new listings and price drops** — perfect for deal alerts, valuation feeds, and competitor watching.
- **Valuation & pricing models** — feed structured specs (power, mileage, year, emissions, equipment) into residual-value and pricing engines.
- **Cross-border arbitrage** — compare the same make/model across all 8 AutoScout24 countries to find the best buy.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **AutoScout24 Scraper**, set a make/model and filters (or paste AutoScout24 URLs), and click **Start**.
3. Watch cars stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "mode": "search",
    "make": "Audi",
    "model": "A4",
    "countries": ["germany", "austria"],
    "priceFrom": 10000,
    "priceTo": 25000,
    "yearFrom": 2018,
    "mileageTo": 120000,
    "fuelTypes": ["diesel", "petrol"],
    "transmission": "automatic",
    "sort": "price_asc",
    "includeDetails": true,
    "emitDealerLeads": true,
    "maxResults": 200
}
```

- **mode** — `search` (cars from a make/model/filter search), `carDetail` (full records for offer URLs you paste), or `dealerLeads` (car-dealer B2B profiles).
- **make / model** — e.g. `BMW` / `X5`. Leave model empty for all models; leave both empty to search by filters only.
- **countries** — any of `germany, austria, belgium, spain, france, italy, luxembourg, netherlands` (names or codes). Empty = all 8.
- **startUrls** — paste AutoScout24 URLs directly: search pages (`/lst/...`), single offers (`/offers/...`), or dealer pages (`/dealerinfo/...`). Auto-routed by type.
- **Filters** — `priceFrom/To`, `yearFrom/To`, `mileageFrom/To`, `fuelTypes`, `transmission`, `bodyTypes`, `powerFromKw/ToKw`, `condition` (new/used), `sort`.
- **includeDetails** *(default false)* — open each car's offer page for the complete record (all equipment, consumption & CO₂, emission class, accident & service history, previous owners, colours, full description).
- **emitDealerLeads** *(default false)* — also output one deduplicated dealer-lead record per unique dealer.
- **enrichDealerEmails** *(default false)* — crawl each dealer's own website (home + imprint/contact) for a public contact email.
- **monitorMode** *(default false)* — emit only cars that are **new or whose price changed** since the last run (and only dealers not seen before).

### Output

One record per car (`type: "car"`), full vehicle records (`type: "carDetail"`), and optional dealer leads (`type: "dealerLead"`):

```json
{
    "type": "car",
    "id": "c74cfad6-2509-4382-b792-4e0e0e89d252",
    "url": "https://www.autoscout24.com/offers/audi-a4-avant-2-0-tdi-...",
    "make": "Audi",
    "model": "A4",
    "version": "Avant 2.0 TDI S tronic",
    "price": { "amount": 10450, "currency": "EUR", "symbol": "€", "formatted": "€ 10,450" },
    "superDeal": false,
    "mileageKm": 246950,
    "firstRegistration": "01/2018",
    "registrationYear": 2018,
    "transmission": "Automatic",
    "fuel": "Diesel",
    "powerKw": 110,
    "powerHp": 150,
    "engineDisplacementCcm": 1968,
    "location": { "countryCode": "DE", "zip": "58453", "city": "Witten", "display": "Witten, 58453" },
    "seller": {
        "type": "Dealer",
        "companyName": "Automobile Kurt",
        "phone": "+49 (0)163 - 4522788",
        "dealerSlug": "automobile-kurt-recklinghausen-45661-1"
    },
    "dealerRatingStars": 4.5,
    "image": "https://prod.pictures.autoscout24.net/listing-images/...640x480.webp",
    "imageCount": 15,
    "scrapedAt": "2026-06-17T16:00:00.000Z"
}
```

A `dealerLead` record adds: `companyName`, full `address`, `phones`, `fax`, `website`, `email`, `emails`, `vatId`, `contactPersons`, `ratingAverage`, `ratingCount`, `reviews`, `openingHours`, `additionalServices`, `branchCount`, and `leadScore` (0–100).

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it hourly/daily to watch a make/model, city, or dealer for new listings and price drops; ideal for deal alerts and lead pipelines.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, price-alert email) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/autoscout24-scraper').call({
    make: 'BMW',
    model: 'X5',
    countries: ['germany'],
    yearFrom: 2019,
    sort: 'age_newest',
    monitorMode: true,
    emitDealerLeads: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} cars & dealer leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new dealer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get pinged when a monitored search finds new cars or price drops.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find diesel Audi A4s under €20k in Germany and list the dealers" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **vehicle & marketplace intelligence stack**:

- **[SGCarmart Used Car Scraper](https://apify.com/scrapesage/sgcarmart-used-car-scraper)** — Singapore used-car listings, prices & dealer data.
- **[eBay Scraper](https://apify.com/scrapesage/ebay-scraper)** — listings, sold comps & seller leads.
- **[Reverb Scraper](https://apify.com/scrapesage/reverb-scraper)** — marketplace listings, price guide & seller leads.
- **[Gumtree Scraper](https://apify.com/scrapesage/gumtree-scraper)** — UK classifieds: cars, property, jobs & seller leads.
- **[Craigslist Scraper](https://apify.com/scrapesage/craigslist-scraper)** — US classifieds across cars, housing, for-sale & services.
- **[Made-in-China Scraper](https://apify.com/scrapesage/made-in-china-scraper)** — B2B suppliers, products & dealer leads.
- **[Shopify Store Scraper](https://apify.com/scrapesage/shopify-store-scraper)** — products, variants, prices & merchant leads.
- **[AliExpress Scraper](https://apify.com/scrapesage/aliexpress-scraper)** — products, prices, variants & supplier leads.

### Tips

- **Big searches**: AutoScout24 paginates the first ~4,000 results per search. To exhaust a popular make/model, split runs by country, price band, or registration year.
- **Newest first + monitoring**: set `sort` to **Newest listings first** and turn on `monitorMode` to capture only fresh inventory and price changes on each scheduled run.
- **Proxies**: the default Apify datacenter proxy works well; switch to Residential in the proxy input for very large or aggressive runs.
- **Cost control**: dealer profiles are deduplicated per dealer, and website email enrichment only runs for dealers that actually list a website.

### FAQ

**How do I scrape cars for a specific make and model?** Set `make` and `model` (e.g. `Volkswagen` / `Golf`) and pick your `countries`. Add filters like `priceTo`, `yearFrom`, `mileageTo`, or `fuelTypes` to narrow the search.

**Can I scrape a single car's full details?** Yes — set `mode` to **Car details** and paste the offer URLs (`autoscout24.com/offers/...`) into `startUrls`, or turn on `includeDetails` in search mode.

**Does it get dealer contact details?** Every car listing includes the dealer's name and phone. **Dealer leads** mode adds the website, address, VAT (when published), opening hours, ratings and reviews, plus — with email enrichment on — a contact email crawled from the dealer's own website.

**Can I monitor price drops?** Yes. Turn on `monitorMode` and schedule the run. The actor remembers each car's price and re-emits only cars that are new or whose price changed.

**Which countries are covered?** Germany, Austria, Belgium, Spain, France, Italy, Luxembourg and the Netherlands — AutoScout24's core markets, in one run.

**Is scraping AutoScout24 legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (e.g. GDPR for personal data) and AutoScout24's terms.

**A field is null — why?** Some sellers don't publish equipment, colours, accident history, or a website. Fields are `null` only when the data genuinely isn't listed, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

<b>Search cars</b> = listings from a make/model/filter search (the default). <b>Car details</b> = full vehicle records for offer URLs you provide (every spec, equipment, emissions & history). <b>Dealer leads</b> = car-dealer B2B profiles with phone, website, email, VAT, ratings & a lead score.

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

Car brand to search, e.g. <code>Audi</code>, <code>BMW</code>, <code>Volkswagen</code>, <code>Mercedes-Benz</code>, <code>Toyota</code>, <code>Tesla</code>. Leave empty to search all makes (with the filters below).

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

Model within the make, e.g. <code>A4</code>, <code>X5</code>, <code>Golf</code>, <code>Model 3</code>. Requires a make. Leave empty for all models of the make.

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

Marketplaces to include. AutoScout24 covers Germany, Austria, Belgium, Spain, France, Italy, Luxembourg & the Netherlands. Use names or codes (<code>germany</code>/<code>de</code>, <code>italy</code>/<code>it</code>…). Empty = all 8 countries.

## `startUrls` (type: `array`):

Paste AutoScout24 URLs directly: search result pages (<code>autoscout24.com/lst/...</code>), single car offers (<code>/offers/...</code>), or dealer pages (<code>/dealerinfo/...</code>). Auto-routed by type; used in addition to the search filters.

## `priceFrom` (type: `integer`):

Only cars at or above this price.

## `priceTo` (type: `integer`):

Only cars at or below this price.

## `yearFrom` (type: `integer`):

Only cars first registered in this year or later, e.g. <code>2018</code>.

## `yearTo` (type: `integer`):

Only cars first registered in this year or earlier.

## `mileageFrom` (type: `integer`):

Only cars with at least this many kilometres.

## `mileageTo` (type: `integer`):

Only cars with at most this many kilometres (e.g. <code>100000</code>).

## `fuelTypes` (type: `array`):

Filter by fuel. Options: <code>petrol</code>, <code>diesel</code>, <code>electric</code>, <code>hybrid</code>, <code>lpg</code>, <code>cng</code>, <code>hydrogen</code>, <code>ethanol</code>.

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

Gearbox type.

## `bodyTypes` (type: `array`):

Filter by body style: <code>compact</code>, <code>convertible</code>, <code>coupe</code>, <code>suv</code>, <code>station-wagon</code>, <code>sedan</code>, <code>van</code>, <code>transporter</code>, <code>other</code>.

## `powerFromKw` (type: `integer`):

Minimum engine power in kilowatts (1 kW ≈ 1.36 hp).

## `powerToKw` (type: `integer`):

Maximum engine power in kilowatts.

## `condition` (type: `string`):

New, used, or both.

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

How to order search results. Use <b>Newest first</b> with monitoring to catch fresh listings.

## `keyword` (type: `string`):

Free-text keyword added to the search (e.g. a trim or equipment word). Make/model filters are more reliable than keyword alone.

## `includeDetails` (type: `boolean`):

For each car found, open its offer page to capture the complete record: all equipment, fuel consumption & CO₂, emission class, accident & service history, previous owners, colours, doors/seats and the full description. Adds one request per car (billed as a Car detail).

## `emitDealerLeads` (type: `boolean`):

In Search / Car-detail mode, also push one deduplicated dealer-lead record (type = "dealerLead") for every unique dealer found — with phone, website, email, VAT, address, ratings, opening hours and a 0–100 lead score.

## `enrichDealerEmails` (type: `boolean`):

When a dealer lists their own website, visit it (home + imprint/contact, hard-capped) to extract a public contact email. Only runs for dealers that have a website.

## `maxReviewsPerDealer` (type: `integer`):

How many dealer reviews to include in each dealer-lead record (0 to skip reviews).

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

Maximum number of cars to scrape across all searches. AutoScout24 paginates the first ~4,000 results per search — split by make/model, country or price band to go deeper.

## `maxDealers` (type: `integer`):

Maximum number of dealer-lead profiles to fetch (Dealer-leads mode, or when "emit dealer-lead records" is on).

## `deduplicateResults` (type: `boolean`):

Skip records already emitted in the same run (recommended).

## `monitorMode` (type: `boolean`):

Remember fingerprints across runs in a named key-value store and emit ONLY cars that are new or whose price changed since last time (and only dealers not seen before). Perfect for price-drop alerts and new-inventory watches. Works with Apify Schedules.

## `monitorKey` (type: `string`):

Names the memory used by monitoring mode. Use a distinct key per saved search so different watches don't share state.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. 6–10 is a good balance for AutoScout24.

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

Proxy settings. The default Apify Proxy (datacenter) works well; switch to Residential for extra resilience on very large runs.

## Actor input object example

```json
{
  "mode": "search",
  "make": "Audi",
  "countries": [
    "germany"
  ],
  "transmission": "",
  "condition": "all",
  "sort": "standard",
  "includeDetails": false,
  "emitDealerLeads": false,
  "enrichDealerEmails": false,
  "maxReviewsPerDealer": 10,
  "maxResults": 200,
  "maxDealers": 200,
  "deduplicateResults": true,
  "monitorMode": false,
  "monitorKey": "default",
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped records as JSON items 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 = {
    "make": "Audi",
    "countries": [
        "germany"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/autoscout24-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 = {
    "make": "Audi",
    "countries": ["germany"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/autoscout24-scraper").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 '{
  "make": "Audi",
  "countries": [
    "germany"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapesage/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/VrjBdAozbE8wW9qty/builds/WueoJ7xbq6ankCQ61/openapi.json