# AutoScout24 Scraper — Cars, Prices, Specs & Dealer Contacts (`haketa/autoscout24-scraper`) Actor

Scrape AutoScout24 car listings across 8 European markets (DE, AT, BE, ES, FR, IT, LU, NL) by make, model, filters or URL. Get price, mileage, power, fuel, transmission, location, dealer name & phone, photos and specs. Export to JSON/CSV/Excel for price monitoring and automotive leads.

- **URL**: https://apify.com/haketa/autoscout24-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** E-commerce, Lead generation, Business
- **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. 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 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, Specs & Dealer Contacts

Extract structured car-listing data from **AutoScout24**, Europe's largest online car marketplace with millions of new and used vehicles across Germany, Austria, Belgium, Spain, France, Italy, Luxembourg and the Netherlands. Search by make, model and filters — or paste any AutoScout24 URL — and get clean, ready-to-use data for every listing: **price, mileage, first registration, power, fuel, transmission, CO₂, full location, dealer name & phone, photos and vehicle specs**.

No code, no login, no browser extensions. Run it from the Apify Console, on a schedule, or from your own app via the API. Results download as **JSON, CSV, Excel, HTML or XML**, or sync straight into Google Sheets, Airtable, Make, Zapier and n8n.

> **🌍 Coverage — 8 European markets:** Germany, Austria, Belgium, Spain, France, Italy, Luxembourg and the Netherlands. Search one country or all eight in a single run. All values (fuel, transmission, condition) are returned in English, so your dataset is the same regardless of market.

***

### 📋 What this scraper does

AutoScout24 lists millions of cars from thousands of dealers and private sellers across Europe. This actor turns those search-result pages into a clean, structured dataset you can analyse, monitor or feed into another system.

Tell it a make and model (for example `bmw` / `3er`, or `audi` / `a4`), add optional filters, and it will:

- ✅ Collect every listing from the search results, page after page
- ✅ Return the **numeric price** plus the formatted price and AutoScout24's price rating
- ✅ Parse full **vehicle specs** — mileage, power (kW **and** PS), fuel, transmission, engine size, CO₂ and fuel consumption
- ✅ Capture the **first registration** date and condition (new / used / demo)
- ✅ Break out the **full location** — country, city, ZIP and street
- ✅ Identify **dealer vs. private** sellers and return the **dealer name, contact and phone number**
- ✅ Save **all photo URLs** for each listing
- ✅ Optionally open each listing for its **full description, exterior colour and warranty**

Values like fuel and transmission are normalised to English (Petrol, Diesel, Electric, Automatic, Manual), so your dataset is language-neutral regardless of the local edition.

Every listing is de-duplicated by ID, so you never get the same car twice in a run.

***

### ⭐ Why choose this AutoScout24 scraper

- **Dealer contact details for lead generation.** Most listings include the dealer's name, profile page and **phone number** — build clean B2B lead lists by brand, region or price segment.
- **Complete, normalised specs.** Power in both kW and PS, mileage as a real number, CO₂ and consumption, engine size — parsed and ready to filter, not raw strings.
- **Pan-European coverage.** One run can span Germany, Austria, Belgium, Spain, France, Italy, Luxembourg and the Netherlands — or a single country.
- **Structured location.** Country, city, ZIP and street as separate fields for mapping and regional analysis.
- **Fast and economical.** Data comes straight from the search results, so a few hundred listings finish in under a minute at very low cost.

***

### 💡 Popular use cases

| Use case | How this scraper helps |
| --- | --- |
| **Price monitoring & repricing** | Track asking prices for any make/model across Europe and benchmark your own stock. |
| **Vehicle valuation** | Gather comparable cars with mileage, year and spec to value a vehicle accurately. |
| **Dealer lead generation** | Build lists of dealers by brand, city or price band with name, page and phone. |
| **Market research** | Measure supply, average price and dealer/private mix for any segment. |
| **Arbitrage & sourcing** | Spot under-priced cars the moment they are listed, filtered by price rating. |
| **Inventory & competitor tracking** | Watch how specific dealers price and rotate their stock over time. |
| **Dashboards & data products** | Feed a clean, normalised car-listing feed into BI tools, spreadsheets or your database. |

***

### 🚀 Quick start

1. Open the actor in the Apify Console.
2. Enter a **Make** (e.g. `bmw`) and optionally a **Model** (e.g. `3er`).
3. (Optional) Choose **Countries**, a **price range**, **year** or **mileage** filters.
4. Keep the default Apify Proxy turned on.
5. Click **Start**, then download your data from the **Storage → Dataset** tab.

For a first test, leave **Max items** at 100 and **Fetch listing details** off — you'll get clean listing data in well under a minute.

***

### ⚙️ Input

| Field | Type | Description |
| --- | --- | --- |
| **Make** | string | Brand slug, e.g. `bmw`, `audi`, `volkswagen`, `mercedes-benz`. Leave empty for all makes. |
| **Model** | string | Model slug, e.g. `3er`, `a4`, `golf`. Requires Make. |
| **Countries** | array | Countries to include (Germany, Austria, Belgium, Spain, France, Italy, Luxembourg, Netherlands). |
| **Condition** | select | New, used, or both. |
| **Price from / to (€)** | integer | Price range in euros. |
| **First registration year from / to** | integer | Registration-year range, e.g. 2015–2022. |
| **Mileage from / to (km)** | integer | Mileage range in km. |
| **Fuel type** | select | Petrol, Diesel, Electric, LPG or CNG. |
| **Transmission** | select | Manual, Automatic or Semi-automatic. |
| **Exclude damaged** | boolean | Hide accident/damaged listings. |
| **Sort by** | select | Newest first (most stable pagination), price, mileage or relevance. |
| **Start URLs** | array | Paste full AutoScout24 search URLs to scrape directly. Overrides the fields above. |
| **Fetch listing details** | boolean | Open each listing for full description, colour and warranty. Slower — off by default. |
| **Max items** | integer | Maximum listings to collect. Default 100. |
| **Proxy** | object | Proxy configuration. Apify Proxy is recommended and on by default. |

#### Example 1 — Make + model

```json
{
  "make": "bmw",
  "model": "3er",
  "countries": ["D"],
  "maxItems": 200
}
```

#### Example 2 — Filtered search (year, price, fuel)

```json
{
  "make": "audi",
  "model": "a4",
  "countries": ["D", "A"],
  "yearFrom": 2018,
  "priceTo": 25000,
  "fuelType": "D",
  "sortBy": "price",
  "maxItems": 300
}
```

#### Example 3 — Full details for valuation

```json
{
  "make": "porsche",
  "model": "911",
  "fetchDetails": true,
  "maxItems": 100
}
```

#### Example 4 — Scrape an exact AutoScout24 URL

```json
{
  "startUrls": [
    "https://www.autoscout24.de/lst/mercedes-benz/e-klasse?atype=C&cy=D&fregfrom=2019&priceto=40000"
  ],
  "maxItems": 500
}
```

> **Tip:** For complex filters, build the search on autoscout24.com/de, then paste the resulting URL into **Start URLs** — the scraper paginates through it automatically.

***

### 📦 Output

Each listing becomes one dataset record:

```json
{
  "listingId": "457433452",
  "title": "BMW 520 d xDrive M Sport LED ACC NAVI Kamera",
  "make": "BMW",
  "model": "520",
  "modelGroup": "5er",
  "variant": "520 d xDrive M Sport",
  "price": 33450,
  "priceText": "€ 33.450",
  "priceEvaluation": 1,
  "condition": "Used",
  "firstRegistration": "05/2021",
  "year": "2021",
  "mileage": 69090,
  "powerKw": 140,
  "powerPs": 190,
  "fuel": "Diesel",
  "transmission": "Automatic",
  "engineCc": 1995,
  "fuelConsumption": "6,0 l/100 km (komb.)",
  "co2Emissions": "158 g/km (komb.)",
  "damaged": false,
  "country": "DE",
  "city": "Velbert",
  "zip": "42551",
  "street": "Beeskower Straße 23",
  "sellerType": "Dealer",
  "sellerName": "Marc Wissmann Automobile",
  "sellerContact": "Marc Wissmann",
  "phone": "+49205123839",
  "dealerUrl": "https://www.autoscout24.de/haendler/marc-wissmann-automobile",
  "imageUrl": "https://prod.pictures.autoscout24.net/listing-images/...jpg",
  "imageCount": 17,
  "url": "https://www.autoscout24.de/angebote/bmw-520-...",
  "searchTerm": "bmw 520",
  "scrapedAt": "2026-07-01T09:42:00.000Z"
}
```

With **Fetch listing details** enabled, each record also gets:

```json
{
  "description": "Scheckheftgepflegt, 1. Hand, Nichtraucherfahrzeug ...",
  "bodyColor": "Black",
  "warranty": "12 months"
}
```

#### Output fields

| Field | Description |
| --- | --- |
| `listingId` | Unique AutoScout24 listing ID. |
| `title` | Full vehicle title. |
| `make` / `model` / `modelGroup` / `variant` | Brand, model, series and version. |
| `price` | Price as a number, in euros. |
| `priceText` | Formatted price. |
| `priceEvaluation` | AutoScout24 price rating (deal indicator). |
| `condition` | New / Used / Demonstration etc. |
| `firstRegistration` / `year` | First registration (MM/YYYY) and year. |
| `mileage` | Odometer in km (numeric). |
| `powerKw` / `powerPs` | Power in kW and PS. |
| `fuel` | Fuel type (Petrol, Diesel, Electric, Hybrid…). |
| `transmission` | Manual / Automatic / Semi-automatic. |
| `engineCc` | Engine displacement in cm³. |
| `fuelConsumption` | Combined consumption. |
| `co2Emissions` | Combined CO₂ emissions. |
| `damaged` | Whether the car is currently damaged. |
| `country` / `city` / `zip` / `street` | Full location. |
| `sellerType` | Dealer or Private. |
| `sellerName` / `sellerContact` | Dealer/company name and contact person. |
| `phone` | Seller phone number. |
| `dealerUrl` | Dealer profile page. |
| `imageUrl` / `imageCount` / `images` | Main photo, count and all photo URLs. |
| `url` | Listing detail page. |
| `description` | Full description *(with Fetch details)*. |
| `bodyColor` | Exterior colour *(with Fetch details)*. |
| `warranty` | Warranty *(with Fetch details)*. |
| `searchTerm` | The search that produced this record. |
| `scrapedAt` | Extraction timestamp. |

***

### 🚘 Popular makes & model slugs

Use these in the **Make** / **Model** fields (or in a Start URL):

| Make | Slug | Popular model slugs |
| --- | --- | --- |
| BMW | `bmw` | `1er`, `3er`, `5er`, `x1`, `x3`, `x5` |
| Audi | `audi` | `a3`, `a4`, `a6`, `q3`, `q5` |
| Mercedes-Benz | `mercedes-benz` | `a-klasse`, `c-klasse`, `e-klasse`, `glc` |
| Volkswagen | `volkswagen` | `golf`, `polo`, `passat`, `tiguan` |
| Porsche | `porsche` | `911`, `cayenne`, `macan` |
| Ford | `ford` | `focus`, `fiesta`, `kuga` |
| Opel | `opel` | `corsa`, `astra`, `insignia` |
| Renault | `renault` | `clio`, `megane`, `captur` |
| Toyota | `toyota` | `yaris`, `corolla`, `rav-4` |
| Tesla | `tesla` | `model-3`, `model-y`, `model-s` |

Leave **Model** empty to scrape all models of a make, or leave both empty for all cars.

***

### 🧭 Tips for best results

- **Newest first = stable pagination.** The default `Newest first` sort gives the cleanest pagination across pages.
- **Split large searches.** AutoScout24 caps a single search at ~4000 results (200 pages). For a full model, split by year, price band or country to go beyond the cap.
- **Keep runs fast and cheap:** leave *Fetch listing details* off when you only need price, specs, location and dealer phone — the list already contains all of that.
- **Target dealers only:** filter the output by `sellerType = Dealer` for lead lists, or `Private` for private-sale analysis.
- **Use Start URLs for anything complex** — every filter you set on the website is preserved in the URL.

***

### 🔌 Integrations & export

- **Download formats:** JSON, CSV, Excel, HTML, XML, RSS.
- **Google Sheets / Airtable / Make / Zapier / n8n:** push results automatically after each run.
- **API:** start runs and fetch data with the Apify API or the JavaScript / Python clients.
- **Scheduling:** run hourly, daily or weekly to track prices and new listings over time.
- **Webhooks:** trigger your own services when a run finishes.

#### Run via API (example)

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR~autoscout24-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "make": "bmw", "model": "3er", "maxItems": 200 }'
```

***

### ❓ FAQ

**Do I need an AutoScout24 account or API key?**
No. You only need an Apify account and the proxy that ships with the actor.

**Why is a proxy recommended?**
AutoScout24 rate-limits repeated requests from a single IP. The default Apify Proxy keeps runs reliable at scale.

**Which countries are covered?**
Germany, Austria, Belgium, Spain, France, Italy, Luxembourg and the Netherlands — pick one or several.

**Can I get the dealer's phone number?**
Yes — most dealer listings include a phone number, along with the dealer name and profile page. A minority of sellers hide contact details.

**How many listings can I get per search?**
As many as the search returns, up to the limit you set. AutoScout24 caps a single search at ~4000 results, so split large models by year, price or region.

**Does it return duplicates?**
No. Every listing is de-duplicated by its AutoScout24 ID within a run.

**How fast / how expensive is it?**
Listing-only runs are fast and inexpensive because data comes straight from the search results. Enabling *Fetch listing details* opens one extra page per listing, so it's slower — enable it only when you need the extra fields.

***

### ⚖️ Legal & responsible use

This actor collects **publicly available** information from AutoScout24 search pages — the same data any visitor can see without logging in. It does not bypass logins or access private data.

You are responsible for how you use the data. Please:

- Respect AutoScout24's Terms of Use and applicable data-protection law (GDPR).
- Use the data for lawful purposes such as price research, analytics and market intelligence.
- Do not use scraped personal data for spam or any purpose that infringes individual privacy.

If you have questions about compliance for your specific use case, consult a legal professional.

***

### 🛟 Support

Need a field added, a market expanded, or hit an issue? Open a ticket from the actor's **Issues** tab and include your input configuration — most requests are quick to address.

Happy scraping! 🚗

### 📅 Changelog & Maintenance

**Last updated:** 2026-07-02 — Actor verified and maintained. Data pipeline tested for quality, structure and freshness; selectors/endpoints confirmed against the live site.

# Actor input Schema

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

Pick a car brand to search. Leave on "All makes" to get a mixed sample of the newest listings across every brand.

## `makeOther` (type: `string`):

Only if your brand is not in the list above. Type the brand exactly as it appears in an AutoScout24 URL, e.g. 'aston-martin' or 'ds-automobiles'. This overrides the dropdown.

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

Narrow to one model, e.g. '3er', 'a4', 'golf', 'corsa'. Works best together with a make. Leave empty for all models.

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

Which country markets to include. AutoScout24 covers most of Europe. Leave empty for all covered countries.

## `adType` (type: `string`):

Show new cars, used cars, or both.

## `fuelType` (type: `string`):

Only show cars with this fuel type. Leave on "Any" for all.

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

Only show cars with this gearbox. Leave on "Any" for all.

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

Minimum price in euros. Leave empty for no minimum.

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

Maximum price in euros. Leave empty for no maximum.

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

Earliest first-registration year, e.g. 2015. Leave empty for any.

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

Latest first-registration year. Leave empty for any.

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

Minimum mileage in km. Leave empty for any.

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

Maximum mileage in km. Leave empty for any.

## `excludeDamaged` (type: `boolean`):

Hide accident and damaged listings.

## `sortBy` (type: `string`):

How results are ordered. "Newest first" gives the freshest, most diverse mix.

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

Open each listing for extra data: full description, exterior colour and warranty. Slower and uses more traffic — leave off for fast collection (the list already includes price, specs, location and dealer phone).

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

Maximum number of listings to collect. Set 0 for unlimited (a single search caps at ~4000 results). Default 100.

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

Power-user option: paste full AutoScout24 search URLs to scrape directly. Build the search you want on autoscout24.com, then copy the address here. When set, this overrides the brand and filters above.

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

Proxy is strongly recommended for reliable results. Apify Residential Proxy (Germany) works well and is preselected.

## Actor input object example

```json
{
  "make": "",
  "countries": [
    "D"
  ],
  "adType": "both",
  "fuelType": "",
  "transmission": "",
  "excludeDamaged": false,
  "sortBy": "age",
  "fetchDetails": false,
  "maxItems": 100,
  "startUrls": [
    "https://www.autoscout24.com/lst/audi/a5?atype=C&cy=D&fregfrom=2018"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `listingId` (type: `string`):

AutoScout24 listing ID

## `title` (type: `string`):

Full vehicle title

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

Brand

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

Model

## `modelGroup` (type: `string`):

Model group/series

## `variant` (type: `string`):

Version/variant

## `price` (type: `string`):

Numeric price in euros

## `priceText` (type: `string`):

Formatted price

## `priceEvaluation` (type: `string`):

AutoScout24 price evaluation

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

New / Used / Demo etc.

## `firstRegistration` (type: `string`):

First registration (MM/YYYY)

## `year` (type: `string`):

First registration year

## `mileage` (type: `string`):

Odometer in km

## `powerKw` (type: `string`):

Power in kW

## `powerPs` (type: `string`):

Power in PS/HP

## `fuel` (type: `string`):

Fuel type

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

Gearbox

## `engineCc` (type: `string`):

Engine displacement in cm³

## `fuelConsumption` (type: `string`):

Combined consumption

## `co2Emissions` (type: `string`):

Combined CO₂ emissions

## `damaged` (type: `string`):

Whether the vehicle is currently damaged

## `country` (type: `string`):

Country code

## `city` (type: `string`):

City

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

Postal code

## `street` (type: `string`):

Street address

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

Dealer or Private

## `sellerName` (type: `string`):

Dealer/company name

## `sellerContact` (type: `string`):

Contact person

## `phone` (type: `string`):

Seller phone number

## `dealerUrl` (type: `string`):

Dealer profile URL

## `imageUrl` (type: `string`):

First image URL

## `imageCount` (type: `string`):

Number of photos

## `images` (type: `string`):

All image URLs

## `url` (type: `string`):

Listing detail page URL

## `description` (type: `string`):

Full description (with Fetch details)

## `bodyColor` (type: `string`):

Exterior colour (with Fetch details)

## `warranty` (type: `string`):

Warranty in months (with Fetch details)

## `searchTerm` (type: `string`):

Search used

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "countries": [
        "D"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "countries": ["D"],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "countries": [
    "D"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call haketa/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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