# AutoScout24 Scraper — Used Car Listings & Prices API | $0.49/1k (`glasswing/autoscout24-scraper`) Actor

Scrape AutoScout24 used car listings from every European country site: price, price rating, make, model, first registration, mileage, fuel, gearbox, power, location, dealer name and photos. Search by URL or by make, model, price and year. No login. Export CSV, JSON or Excel.

- **URL**: https://apify.com/glasswing/autoscout24-scraper.md
- **Developed by:** [Raffy](https://apify.com/glasswing) (community)
- **Categories:** E-commerce, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

### What does AutoScout24 Scraper do?

AutoScout24 Scraper extracts **used car listings with prices** from [AutoScout24](https://www.autoscout24.com/), one of Europe's largest online car marketplaces, and delivers them as clean, structured JSON, CSV or Excel. It works as an **AutoScout24 API alternative**: paste a search URL from any AutoScout24 country site (autoscout24.com, .de, .it, .fr, .nl, .be, .at, .es, .lu, .pl) or just type a make, model and a few filters, and get one row per car back in seconds, without a browser, without residential proxies and without writing a scraper yourself.

Typical use cases:

- Track asking prices, mileage and age of a model across Germany, Italy, France and the rest of Europe for pricing, valuation or import/export decisions.
- Build a dealer lead list: every dealer listing carries the dealer's business name, AutoScout24 dealer page, rating and city.
- Feed a car-deal alert, a market report or a spreadsheet with fresh listings every day, sorted by price or first registration.

It does **not** log in, read hidden data or collect private sellers' personal data. It reads only the public search result pages.

### Why use AutoScout24 Scraper?

- **Fast and cheap.** One page request returns 20 listings (pure HTTP, no headless browser), so the default run of 20 cars finishes in a few seconds and 1,000 listings take about a minute.
- **Search the easy way.** Paste any AutoScout24 search URL with all its filters, or fill in make, model, country, price, year, mileage, fuel, body type and seller type. A typo in the make or model returns one unbilled `not_found` row instead of thousands of unrelated cars.
- **Honest results.** Every row carries a `status` (`ok`, `not_found`, `error`), so you (or an AI agent calling this Actor) can tell "no car matches" apart from "the site could not be read". You are only billed for `ok` rows.
- **Privacy by design.** Private sellers' names, phone numbers, e-mails and street addresses are never read into the output; dealer rows carry only the business name.
- **Runs anywhere Apify runs.** Schedule it, call it from the API, chain it with other Actors, or receive results via integrations (Google Sheets, Slack, webhooks, Zapier, Make).

### What data can AutoScout24 Scraper extract?

| Field | Type | Description |
|---|---|---|
| `listingId` | string | AutoScout24 listing id |
| `title` | string | Make, model and version in one line, e.g. `BMW 440 M440d xDrive Coupe` |
| `make` | string | Make, e.g. `BMW` |
| `model` | string | Model, e.g. `440`, `Golf`, `A4` |
| `modelGroup` | string | Model family, e.g. `4 Series` |
| `variant` | string | AutoScout24 model variant, e.g. `Coupe`, `Touring`, `Avant` |
| `version` | string | Version text written by the seller |
| `price` | number | Asking price |
| `currency` | string | ISO 4217 currency code (`EUR` on every AutoScout24 site tested) |
| `priceRating` | string | AutoScout24's own price label: `top-price`, `good-price`, `fair-price`, `somewhat-expensive`, `expensive` or `toolow-price` |
| `firstRegistration` | string | First registration as `MM/YYYY` |
| `year` | integer | Year of first registration |
| `mileageKm` | integer | Mileage in kilometres |
| `fuel` | string | Fuel type, in the language of the country site (`Diesel`, `Gasoline`, `Benzin` ...) |
| `transmission` | string | Gearbox, in the language of the country site |
| `powerKw` | integer | Engine power in kW |
| `powerHp` | integer | Engine power in hp |
| `engineCc` | integer | Engine displacement in cc |
| `bodyType` | string | Body type; filled when your search filters on one body type |
| `color` | string | Exterior colour when the listing states one |
| `condition` | string | `used`, `new`, `employee's car`, `demonstration`, `pre-registered` or `classic` |
| `sellerType` | string | `dealer` or `private` |
| `dealerName` | string | Dealer business name (dealers only) |
| `dealerId` | string | AutoScout24 dealer id (dealers only) |
| `dealerUrl` | string | Dealer page on AutoScout24 (dealers only) |
| `dealerRating` | number | Dealer star rating, 0-5 (dealers with ratings) |
| `dealerReviewCount` | integer | Number of dealer ratings |
| `countryCode` | string | Country of the car, e.g. `DE`, `IT` |
| `zip` | string | Postal code of the car's location |
| `city` | string | City of the car's location |
| `imageUrl` | string | First photo |
| `imageCount` | integer | Number of photos |
| `url` | string | The listing page on AutoScout24 |
| `searchUrl` | string | The search page the row came from |
| `status` | string | `ok`, `not_found` or `error` (see below) |
| `error` | string | Reason when `status` is not `ok` |
| `scrapedAt` | string | ISO 8601 time of extraction |

A field is left out when the listing does not state it (for example `color` or `dealerRating`); a missing field is never a guess. The search page does not show doors, seats or the listing date, so those are not in the output.

#### Result status (tri-state output)

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | The listing was found and extracted. | Yes |
| `not_found` | AutoScout24 answered, but the search has no results, or it does not know the make or model you typed. `error` says which. | No |
| `error` | AutoScout24 could not be read after retries (network error, block, or layout change), or the input was not an AutoScout24 search URL. `error` says why. | No |

### How to scrape AutoScout24 with AutoScout24 Scraper

1. Open the Actor in Apify Console.
2. Paste one or more AutoScout24 search URLs into **AutoScout24 search URLs** (set your filters on the website, then copy the address bar), or fill in **Make**, **Model**, **Country** and the other search fields.
3. Set **Maximum results** (start with the default 20 to see the output).
4. Click **Start**. The run takes about 5-10 seconds for the default input; rows appear in the dataset in real time.
5. Open the **Output** tab or **Export** the dataset as JSON, CSV, Excel, XML or HTML.

To automate it, use the **API** tab (Node.js, Python, curl examples) or add a **Schedule**.

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

This Actor uses **pay-per-event** pricing:

| Event | Price |
|---|---|
| Actor start | $0.005 per run |
| Result (`status: ok` row) | $0.00049 per listing |

Example: 1,000 listings cost about $0.50 ($0.005 to start plus 1,000 x $0.00049). Rows with `status` `not_found` or `error` are never billed. Platform compute is included, so the start fee and the price per result are the whole price list. The $5 of monthly credit on Apify's entry plan covers about 10,000 listings. You can cap spending per run with **Maximum results** and in the run's **Max total charge** option.

### Input

See the **Input** tab for the full schema. The main options:

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of strings | one BMW search in Germany | AutoScout24 search URLs from any country site; every filter in the URL is kept |
| `maxItems` | integer | `20` | Stop after this many listings in total |
| `make` | string | - | Make as in AutoScout24 URLs: `bmw`, `volkswagen`, `mercedes-benz` |
| `model` | string | - | Model as in AutoScout24 URLs: `x5`, `golf`, `a4` (needs `make`) |
| `country` | string | all | `DE`, `AT`, `BE`, `ES`, `FR`, `IT`, `LU` or `NL` |
| `priceFrom` / `priceTo` | integer | - | Asking price range in EUR |
| `yearFrom` / `yearTo` | integer | - | First registration year range |
| `mileageMax` | integer | - | Highest mileage in km |
| `fuel` | string | - | `gasoline`, `diesel`, `electric`, `hybrid-gasoline`, `hybrid-diesel`, `lpg`, `cng`, `hydrogen`, `ethanol`, `other` |
| `bodyType` | string | - | `compact`, `convertible`, `coupe`, `suv`, `station-wagon`, `sedan`, `van`, `transporter`, `other` |
| `sellerType` | string | both | `dealer` or `private` |
| `sort` | string | `standard` | `standard`, `price_asc`, `price_desc`, `year_desc`, `mileage_asc`, `power_desc` |
| `domain` | string | `com` | AutoScout24 site for the field search; only changes the language of text fields |
| `proxyConfiguration` | object | Apify Proxy off | Optional; datacenter proxy is enough if needed |

The search fields build one extra search next to your URLs. If you fill in a search field and leave the example URL untouched, the example is skipped, so `{"make": "audi"}` returns only Audis.

Example input (a URL search):

```json
{
    "startUrls": ["https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"],
    "maxItems": 20
}
```

Example input (search fields):

```json
{
    "make": "volkswagen",
    "model": "golf",
    "country": "IT",
    "priceTo": 15000,
    "yearFrom": 2018,
    "fuel": "diesel",
    "sort": "price_asc",
    "maxItems": 100
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. Example rows, taken from a real run on the Apify platform:

```json
[
    {
        "url": "https://www.autoscout24.com/offers/bmw-116-i-5-tuer-sportline-service-neu-klima-gasoline-black-cat_ma13mo18480-3398e198-8299-4d12-8433-47e656b8c19f",
        "status": "ok",
        "scrapedAt": "2026-09-27T01:42:10.375Z",
        "listingId": "3398e198-8299-4d12-8433-47e656b8c19f",
        "title": "BMW 116 i*5 Tür*Sportline*Service neu*Klima*",
        "make": "BMW",
        "model": "116",
        "modelGroup": "1 Series",
        "variant": "Hatchback 5-Door",
        "version": "i*5 Tür*Sportline*Service neu*Klima*",
        "price": 5650,
        "currency": "EUR",
        "priceRating": "top-price",
        "firstRegistration": "03/2012",
        "year": 2012,
        "mileageKm": 115000,
        "fuel": "Gasoline",
        "transmission": "Manual",
        "powerKw": 100,
        "powerHp": 136,
        "engineCc": 1598,
        "color": "Black",
        "condition": "used",
        "sellerType": "dealer",
        "dealerName": "AuM PDR Tec",
        "dealerId": "41132321",
        "dealerUrl": "https://www.autoscout24.com/dealerinfo/aum-pdr-tec?atype=C",
        "dealerRating": 5,
        "dealerReviewCount": 17,
        "countryCode": "DE",
        "zip": "72622",
        "city": "Nürtingen",
        "imageUrl": "https://prod.pictures.autoscout24.net/listing-images/3398e198-8299-4d12-8433-47e656b8c19f_776bc376-c73f-42f4-8e52-df6d8b7dc885.jpg/250x188.webp",
        "imageCount": 17,
        "searchUrl": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
    },
    {
        "url": "https://www.autoscout24.com/offers/tesla-model-3-model-3-stnd-rwd-plus-60-kwh-electric-black-cat_ma51520mo74665-b086ce8d-bb99-4727-ba15-08e123324f9c",
        "status": "ok",
        "scrapedAt": "2026-09-27T01:43:07.823Z",
        "listingId": "b086ce8d-bb99-4727-ba15-08e123324f9c",
        "title": "Tesla Model 3 Model 3 Stnd.RWD Plus 60 kWh",
        "make": "Tesla",
        "model": "Model 3",
        "modelGroup": "Model 3",
        "version": "Model 3 Stnd.RWD Plus 60 kWh",
        "price": 13900,
        "currency": "EUR",
        "priceRating": "top-price",
        "firstRegistration": "08/2019",
        "year": 2019,
        "mileageKm": 249350,
        "fuel": "Electric",
        "transmission": "Automatic",
        "powerKw": 239,
        "powerHp": 325,
        "color": "Black",
        "condition": "used",
        "sellerType": "private",
        "countryCode": "NL",
        "zip": "3742",
        "city": "Baarn",
        "imageUrl": "https://prod.pictures.autoscout24.net/listing-images/b086ce8d-bb99-4727-ba15-08e123324f9c_9498cb75-030b-49aa-ba56-abd08294f9a7.jpg/250x188.webp",
        "imageCount": 12,
        "searchUrl": "https://www.autoscout24.com/lst?atype=C&custtype=P&sort=standard&desc=0"
    }
]
```

### Tips

- Keep `maxItems` small while testing, then raise it.
- Pass several search URLs in one run instead of many single-URL runs; you pay the start fee once.
- For more than 4,000 listings of one search, split it by price or year ranges (for example `priceTo: 10000`, then `priceFrom: 10001` and `priceTo: 20000`).
- `imageUrl` is the search-page thumbnail (`.../250x188.webp`); replace `250x188` with `720x540` or `1280x960` for a larger photo.
- If you see `error` rows mentioning blocking, enable Apify Proxy (datacenter) in **Proxy configuration**.

### Limitations

- AutoScout24 serves at most 200 pages of 20 listings (4,000 listings) per search; the Actor follows the pages until **Maximum results** or that last page. Split bigger pulls by price or year ranges.
- The search page does not show doors, seats, the listing date or a per-listing body type; `bodyType` is filled only when your search filters on one body type, and `color` only when the listing states it.
- Listing pages (`/offers/...`), autoscout24.ch (a separate site) and other marketplaces are not supported.
- Results reflect the public page at the time of the run; AutoScout24 may change its layout, in which case rows come back as `error` and the Actor is updated quickly (report it in the **Issues** tab).

### FAQ

#### Is it legal to scrape AutoScout24?

Scraping publicly available data is generally legal, but you are responsible for how you use the output. Read the legal notice below and AutoScout24's terms of service, and do not collect personal data without a legitimate reason.

#### Does the output contain private sellers' names or phone numbers?

No. For private sellers the row says only `sellerType: "private"` and the car's city and postal code. Names, phone numbers, e-mail addresses and street addresses are never extracted. Dealer rows carry the dealer's business name, id, AutoScout24 page and rating.

#### Which AutoScout24 countries work?

Every AutoScout24 country site that uses the `/lst` search pages: autoscout24.com, .de, .at, .it, .fr, .es, .nl, .be, .lu and .pl. Text fields such as `fuel` come in the language of the site you search on; use `domain: "com"` for English.

#### Can I use this Actor from an AI agent or MCP client?

Yes. It runs with no input at all, the search fields are plain strings and numbers, every row is self-describing (`status` + `error`), and results can be fetched via the dataset API or the Apify MCP server.

#### Why did I get fewer rows than `maxItems`?

The search had fewer listings, it reached AutoScout24's last page (200 pages), or the run hit your **Max total charge** limit. Check the run log for "Stopping gracefully".

#### What if a field is missing?

Optional fields are left out when the listing does not state them. If a field that should always be present is missing, open an issue in the **Issues** tab with the run ID.

### Legal and data-protection notice

This Actor extracts only data that AutoScout24 publishes publicly; it does not extract private user data such as e-mail addresses, phone numbers, gender or precise location, and it does not log in or circumvent access controls. However, your results could still contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. You are responsible for complying with AutoScout24's terms of service and applicable law when using the extracted data.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by AutoScout24 or its owners. All trademarks belong to their respective owners.

# Changelog

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

# Actor input Schema

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

Search result pages copied from your browser on any AutoScout24 country site, e.g. https://www.autoscout24.com/lst/bmw/x5?cy=D\&priceto=40000. Every filter in the URL is kept. Listing pages (/offers/...) and other sites are not supported and return one unbilled error row. You can leave the example in place when you use the search fields below: the untouched example is skipped automatically as soon as a search field is filled in.

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

Stop after this many listings have been saved, across all searches. Each saved listing with status `ok` is one billable result. The site serves 20 listings per page and at most 200 pages (4,000 listings) per search; split bigger pulls by price or year ranges.

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

Car make as AutoScout24 writes it in its URLs, e.g. bmw, volkswagen, mercedes-benz, audi, fiat, land-rover. Spaces and capitals are fine ("Mercedes-Benz" works). An unknown make returns one unbilled not\_found row instead of unrelated cars.

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

Model as AutoScout24 writes it in its URLs, e.g. x5, golf, a4, 500, clio. Needs Make. An unknown model returns one unbilled not\_found row instead of every car of the make.

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

Only listings located in this country. Empty = all AutoScout24 countries.

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

Lowest asking price in euros.

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

Highest asking price in euros.

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

Earliest year of first registration, e.g. 2018.

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

Latest year of first registration, e.g. 2022.

## `mileageMax` (type: `integer`):

Highest mileage in kilometres.

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

Fuel type.

## `bodyType` (type: `string`):

Body type. When set, every row carries it in `bodyType` (the search page does not print it per listing otherwise).

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

Only dealer listings or only private listings. Empty = both.

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

Order of the search built from the fields above (URLs keep their own order).

## `domain` (type: `string`):

Which AutoScout24 site runs the search built from the fields. It only changes the language of text fields such as fuel and transmission (autoscout24.de answers "Benzin", .com "Gasoline"); use Country to choose where the cars are.

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

Optional. The Actor works from Apify's datacenter without a proxy. Enable Apify Proxy (datacenter) only if you see blocked requests; residential proxies are not needed.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
  ],
  "maxItems": 20,
  "sort": "standard",
  "domain": "com",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/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 = {
    "startUrls": ["https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/autoscout24-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 '{
  "startUrls": [
    "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glasswing/autoscout24-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/obMjl15qfReGkL1ib/builds/8VosDA2hvmNnRYaKH/openapi.json
