# AutoScout24 Scraper (`s-r/autoscout24-scraper`) Actor

- **URL**: https://apify.com/s-r/autoscout24-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **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/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

## AutoScout24 Scraper

An AutoScout24 scraper that returns car listings with the asking price, the mileage, the first registration, the fuel type and the dealer, plus AutoScout24's own price rating for the car. No login, no API key, no browser.

Nine national markets on one input, each fetched through an exit in its own country so the prices are the ones that market actually shows.

### What you get

- **AutoScout24's own price rating** as `price_label`: `top-price`, `good-price` and so on. That is the site's verdict on whether a car is well priced against comparable listings, and it is not visible in any other feed
- **Suggested retail price beside the asking price**, so the gap is a number rather than a judgement
- **Price as a real number**, taken from the site's raw figure rather than parsed out of "€ 2.900", which is where locale-aware price parsing usually goes wrong
- **Mileage, first registration, fuel type, power and transmission** per car. Fuel arrives as a single letter in the payload and is mapped to a readable value, with the raw code kept alongside
- **Dealer identity and dealer id**, so a whole dealership's stock can be grouped and tracked
- **Nine markets**: Netherlands, Germany, Belgium, France, Italy, Spain, Austria, Poland and Sweden
- **Exact pagination.** The site reports how many results and pages exist, so the walk stops at the real end rather than probing for it
- **Charged per row, not per compute unit.** A flat $0,002 start fee plus what you actually receive

### Why scrape AutoScout24

AutoScout24 is the largest car marketplace in continental Europe: 266.685 listings in the Netherlands and 874.238 in Germany as this was written. For anyone valuing a car, buying stock, or watching a competitor's forecourt, it is the market.

There is no public API. What there is, on every result page, is the complete listing set as JSON inside the page for the browser to render. Reading that is faster than driving a browser and it carries fields the rendered cards leave out, including the price rating and the suggested retail price.

The price rating is the part worth having. AutoScout24 compares each listing to similar cars and labels it, which means the site has already done the comparison you would otherwise build yourself. Combined with `suggested_retail_price` you can find underpriced stock in one pass instead of computing a market curve first.

### Input

| Field | Type | Required | Default | What it does |
|---|---|---|---|---|
| `market` | select | yes | `nl` | Which national site, and therefore the currency and exit country |
| `url` | string | no | – | An AutoScout24 search URL to read instead of the filters below |
| `price_min` / `price_max` | integer | no | – | Price bounds in the market's currency |
| `year_min` | integer | no | – | Earliest first-registration year |
| `mileage_max` | integer | no | – | Upper mileage bound in kilometres |
| `sort` | select | no | `standard` | Price, newest listing, mileage, power or registration year |
| `limit` | integer | no | `40` | Cars to return, 1 to 400 |
| `retries` | integer | no | `3` | Retry attempts per page |

### Output

```json
{
  "position": 1,
  "listing_id": "0cfe1658-969b-4f7f-af09-6a0eafd45bd1",
  "url": "https://www.autoscout24.nl/aanbod/dacia-sandero-1-6-stepway-...",
  "make": "Dacia",
  "model": "Sandero",
  "variant": "Sandero Stepway",
  "title": "Dacia Sandero 1.6 Stepway | Trekhaak | All Season",
  "motor": "1.6 MPI",
  "price": 2900,
  "price_text": "€ 2.900",
  "currency": "€",
  "suggested_retail_price": 12780.0,
  "price_label": "good-price",
  "mileage_km": 157149.0,
  "first_registration": "02-2010",
  "fuel_type": "Petrol",
  "fuel_type_code": "b",
  "seller_type": "Dealer",
  "seller_name": "Autobedrijf Vos",
  "seller_id": "9742",
  "city": "STADSKANAAL",
  "country": "NL",
  "images_count": 12,
  "market": "nl"
}
```

### Use cases

**Finding underpriced stock.** Filter on `price_label` of `top-price` or `good-price` and sort by the gap between `price` and `suggested_retail_price`. AutoScout24 has already compared each car to its peers, so you are reading their verdict rather than rebuilding it. For a trader, that is the whole job in one query.

**Valuing a car before you buy or sell.** Run the make, model and year band with a mileage ceiling, and the returned distribution is the live market for that specification in that country. Because `market` pins the currency and the exit, running the same filter across Netherlands and Germany gives you a cross-border comparison rather than a currency muddle.

**Watching a competitor's forecourt.** `seller_id` groups a dealer's entire stock. Schedule a run, store listing ids, and you see what they took in, what they moved, and what has been sitting for weeks. Standing stock and price cuts are the two signals that tell you how a dealership is really doing.

**Building a residual-value dataset.** Mileage, first registration and price on every row, across nine countries, is enough to fit a depreciation curve per model. That is data leasing companies and insurers pay for and which is otherwise assembled by hand.

### How it compares

| | this actor | `3x1t/mobile-de-scraper-ppr` | `apify/e-commerce-scraping-tool` |
|---|---|---|---|
| Per 1.000 listings | **$2,20** | $1,50 | $6,00 |
| Covers AutoScout24 | **yes** | no | generic |
| Markets | **9** | 1 (Germany) | n/a |
| Site's own price rating | **yes** | no | no |
| Suggested retail price | **yes** | no | no |
| Dealer id for grouping | **yes** | not stated | no |
| Actor-start fee | **none** | none | $0,0001 |

Honest about the other side: the mobile.de actor is cheaper per row and has 130 monthly users against our zero. It covers a different site and only Germany. Nothing on the Store covers AutoScout24 at all.

### Pricing

One event. `listing` costs $0,0022 per car returned, which is $2,20 per 1.000. All pricing is pay-per-event, so you only pay for listings you actually receive. A $0,002 start fee covers the run itself; everything else is charged per row you receive. No per-compute-unit charges.

### Limits and gotchas

- **400 cars per run** across 20 pages. The site itself caps pagination at 200 pages, and the run summary reports both what is available and what was fetched.
- **Filter codes are AutoScout24's own.** `price_min`, `price_max`, `year_min` and `mileage_max` map onto its query parameters, but make and model are internal ids rather than names. For anything beyond those bounds, apply the filters in your browser and paste the URL into `url`.
- **`suggested_retail_price` is not always present.** It appears on cars where AutoScout24 has a reference figure, which is most used stock and few new ones.
- **`power` and `transmission` come from the listing chips**, so their formatting follows the market's language rather than a normalised unit.
- **Prices reflect the pinned exit country**, which is what you want, but it means a market you filter for must match the `market` you selected.
- **Listing ids are per market.** The same car does not appear twice, but a dealer selling across borders will have separate listings with separate ids.

### FAQ

**Can I scrape AutoScout24 without an API key?**
Yes. Every result page carries its listings as JSON for the browser to render, and that is what this actor reads. There is no credential field in the input.

**What is `price_label`?**
AutoScout24's own rating of the asking price against comparable cars, for example `good-price` or `top-price`. It is the site's comparison, already done, and it is the fastest way to find underpriced stock.

**Which countries are covered?**
Nine: Netherlands, Germany, Belgium, France, Italy, Spain, Austria, Poland and Sweden. Each is fetched through an exit in its own country.

**Can I filter by make and model?**
Through the `url` field, yes: apply the filters on the site and paste the resulting URL. The numeric filters (price, year, mileage) are available directly as inputs.

**How do I track one dealer's stock?**
Every row carries `seller_id`. Run a broad search for the region, group by that id, and repeat on a schedule to see what moves.

### Related Actors

- [Marktplaats Scraper](https://apify.com/s-r/marktplaats-scraper) — Dutch classifieds, including cars and bikes
- [Price Scraper](https://apify.com/s-r/price-scraper---extract-prices-availability-from-any-url) — price and availability from any product URL
- [VIN Decoder](https://apify.com/s-r/vin-decoder) — decode a vehicle identification number

# Actor input Schema

## `market` (type: `string`):

Which national AutoScout24 site to read. The proxy exit is pinned to that country, so prices are the ones that market sees.

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

An AutoScout24 search URL to read instead of building one from the filters below. Paste it from your browser after applying any filters you want.

## `price_min` (type: `integer`):

Lower price bound in the market's currency.

## `price_max` (type: `integer`):

Upper price bound in the market's currency.

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

Only cars first registered in or after this year.

## `mileage_max` (type: `integer`):

Upper mileage bound in kilometres.

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

How AutoScout24 should order the results.

## `limit` (type: `integer`):

How many cars to return, 1 to 400. A page carries 20 and the site reports how many pages exist, so the walk stops at the real end.

## `retries` (type: `integer`):

Retry attempts per page, each with a rotated user agent and TLS fingerprint.

## Actor input object example

```json
{
  "market": "nl",
  "url": "https://www.autoscout24.nl/lst/audi/a3",
  "sort": "standard",
  "limit": 40,
  "retries": 3
}
```

# Actor output Schema

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

One row per car.

## `summary` (type: `string`):

Market, total results the site reports, pages available and fetched.

## `errors` (type: `string`):

Per-page failures with a code and a redacted message.

# 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 = {
    "market": "nl",
    "sort": "standard",
    "limit": 40,
    "retries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "market": "nl",
    "sort": "standard",
    "limit": 40,
    "retries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/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 '{
  "market": "nl",
  "sort": "standard",
  "limit": 40,
  "retries": 3
}' |
apify call s-r/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/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/ZloV128rK2KHSrFVM/builds/ctFBCgCzdW0P9YgrC/openapi.json