# AutoScout24 Scraper & API - Used Car Listings, Prices & Data (`s-r/autoscout24-scraper`) Actor

AutoScout24 scraper and data API for nine European markets: every used car listing as a dataset row with asking price, AutoScout24's price rating, mileage, first registration, fuel, power, transmission and dealer. For price monitoring, market research and stock tracking. No login needed.

- **URL**: https://apify.com/s-r/autoscout24-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 run start fees

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 Scraper - Car Listings, Prices and Dealers

AutoScout24 Scraper collects car listings from nine European markets with asking
prices, AutoScout24's own price rating, mileage, registration, fuel, transmission,
power and seller information. Each advertisement becomes one dataset row, ready for
JSON, CSV or Excel exports, comparisons and scheduled searches. You can use the
national market directly or paste a search URL after setting filters in your browser.
No login and no AutoScout24 account are needed.

### What you can collect with AutoScout24 Scraper

The scraper reads listings from the Netherlands, Germany, Belgium, France, Italy,
Spain, Austria, Poland and Sweden. Use it to monitor asking prices for a particular
model, compare advertised vehicles by age and mileage, or collect seller information
for a public inventory overview. Listing identifiers let you recognise the same
advertisement across runs, while the position records its order in the results.

Prices are advertised asking prices. They do not establish the final sale price,
whether the vehicle sold, or its transaction history. Dealer names and locations
come from the listing itself. The searched market and the seller's country are
separate fields because advertisements can appear across borders.

### Use cases for an AutoScout24 scraper

- **Used car price monitoring.** Schedule the same search daily or weekly and follow
  asking prices, price ratings and new offers for one model or price band.
- **Used car dataset for analysis.** Build a used car dataset across markets with
  mileage, first registration, fuel type and power for pricing models or reports.
- **Cross-border comparison.** Run the same filters on several national markets and
  compare what a car is advertised for in Germany, the Netherlands or Italy.
- **Dealer stock tracking.** Follow which dealers list which vehicles, where they are
  located and how quickly listings appear, using `seller_name`, `seller_id` and `city`.
- **Lead lists for automotive services.** Collect public dealer names and locations
  for a region as a starting point for outreach.

### AutoScout24 Scraper compared with the alternatives

**The AutoScout24 website** shows the same listings, but copying them by hand does
not scale beyond a few pages and gives no structured export.

**The official AutoScout24 API** is intended for dealers who create and manage their
own listings. It is not a public search interface for the whole marketplace. This
actor works as a no-code AutoScout24 API for search results: you send the market and
filters, and you receive structured rows through the Apify API, integrations or
dataset exports.

**Writing your own scraper** means maintaining parsing for nine national sites,
pagination and deduplication yourself. This actor already handles those and keeps
its output field names stable between versions.

**Other AutoScout24 actors in the Apify Store** differ in markets, fields and price
models. Compare the fields you need with the output section above; this actor
charges per delivered listing and gives empty searches without listing charges.

### Input

No input fields are required. An empty input searches the Dutch market, returns
up to 40 listings in standard order and allows three attempts per page. Choose
`market` from `nl`, `de`, `be`, `fr`, `it`, `es`, `at`, `pl` and `se`.

The following input was used in a recorded run of the actor:

```json
{
  "market": "nl",
  "sort": "standard",
  "limit": 40,
  "retries": 3
}
```

Set `price_min` and `price_max` to narrow the asking price range. `year_min` restricts
the earliest registration year, between 1950 and 2030. `mileage_max` is the maximum
odometer reading in kilometres. Zero price and mileage values do not add a filter.
The optional `make` and `model` inputs accept AutoScout24's internal identifiers;
they are identifiers rather than manufacturer or model display names.

`sort` accepts `standard`, `price_asc`, `age`, `mileage`, `power` and `year`.
`limit` accepts 1 to 400, and `retries` accepts 1 to 6. Retries are attempts per
page rather than a promise that a blocked page will become available.

For a specific manufacturer and model, paste its search URL in `url`. A recorded
input used `https://www.autoscout24.nl/lst/audi/a3` with `market: nl` and `limit: 25`.
The URL takes precedence over the separate filters and sorting input. Keep `market`
aligned with the country you intend to search. Relative search paths also work.

### Output

The default dataset contains one row per car advertisement. Vehicle fields include
`listing_id`, `url`, `make`, `model`, `variant`, `title`, `motor`, `equipment`,
`mileage_km`, `first_registration`, `fuel_type`, `fuel_type_code`, `power` and
`transmission`. Missing source information remains null rather than being inferred.

Price fields include the numeric `price`, original `price_text`, currency symbol
in `currency`, ISO currency code in `price_currency`, `suggested_retail_price`,
`price_label` and `is_super_deal`. The deal flag reflects the source's actual
eligibility flag. Price labels are preserved as the source provides them.

Seller fields include `seller_type`, `seller_name`, `seller_id`, `city`, `zip` and
`country`. The old `country` field remains the seller's country. `market` identifies
the selected national market and `market_country` provides its uppercase code.
`image` contains the first image URL, and `images_count` records the image count
when available. Other flags are `is_new_offer`, `is_trending` and `available_now`.

Every row also has `position`, `source` and a UTC `fetched_at` timestamp. Existing
dataset fields and their types are preserved, so established exports can continue
to use the same column names.

#### Example output row

This is the first row of a recorded run with the default input (`market: nl`,
40 listings), copied unchanged:

```json
{
  "listing_id": "49228fe2-c0ed-4974-a87a-dd296f514a02",
  "url": "https://www.autoscout24.nl/aanbod/opel-astra-1-4-enjoy-exportprijs-benzine-blauw-cat_ma54mo1916-49228fe2-c0ed-4974-a87a-dd296f514a02",
  "make": "Opel",
  "model": "Astra",
  "variant": "Astra",
  "title": "Opel Astra 1.4 Enjoy | Exportprijs",
  "motor": "1.4",
  "equipment": "Trekhaak, Alarm, Airconditioning, Elektrische ramen, Cruisecontrol, Elektrisch verstelbare buitenspiegels, CD, Radio",
  "price": 995,
  "price_text": "€ 995",
  "currency": "€",
  "suggested_retail_price": 21082,
  "price_label": "toolow-price ",
  "is_super_deal": false,
  "mileage_km": 187362,
  "first_registration": "01-2005",
  "fuel_type": "Petrol",
  "fuel_type_code": "b",
  "power": "66 kW (90 PK)",
  "transmission": "Handgeschakeld",
  "seller_type": "Dealer",
  "seller_name": "Vos Autotrading",
  "seller_id": "47461555",
  "city": "GOOR",
  "zip": "7471 GG",
  "country": "NL",
  "is_new_offer": true,
  "is_trending": false,
  "available_now": true,
  "image": "https://prod.pictures.autoscout24.net/listing-images/49228fe2-c0ed-4974-a87a-dd296f514a02_6a4c793f-c826-4db8-8aeb-2bb97bff57f0.jpg/250x188.webp",
  "images_count": 17,
  "market": "nl",
  "position": 1,
  "source": "autoscout24-scraper",
  "fetched_at": "2026-10-03T23:13:13.412Z",
  "price_currency": "EUR",
  "market_country": "NL"
}
```

The default key-value store contains `summary`, with result counts, the market,
reported source totals, available and fetched pages, priced listings and elapsed
seconds. When a page fails, `errors` records its code and message. Individual page
failures may leave a partial dataset; inspect the run output and errors before
assuming every requested listing was collected.

### Pricing

The live price model charges **$0.0005 per run** and **$0.003 per delivered listing**.
A run returning 40 rows has a listing charge of $0.12 plus the $0.0005 run fee.
An empty search has no listing charges and retains the run fee. Duplicate listing
identifiers are removed before delivery and therefore do not create extra listing
charges. Apify's own platform usage is separate from these actor events.

Users without a paid Apify plan receive at most 10 results per run. Listing events
are charged only for the rows actually delivered. Paid users can request up to
400 listings, subject to the inventory available for their search.

### FAQ

#### Can I use a search URL instead of individual filters?

Yes. Paste an AutoScout24 search URL in `url` and select its market. The URL wins
over the separate filter and sort settings. This is useful when the site's search
form offers a combination you have already configured.

#### Why can a run return fewer listings than the limit?

The limit is a maximum. Inventory may be smaller, duplicate advertisements may
occur on several pages, or a page may fail. The free-plan cap can also restrict
delivery to 10 rows. Review the summary and errors for the explanation.

#### Does an empty search incur listing charges?

No. A search delivering zero rows creates zero listing events. The per-run fee
still applies, as shown in the pricing section.

#### Is there an AutoScout24 API for search results?

AutoScout24 offers an API for dealers to publish their own listings. For searching
the marketplace as a buyer would, this actor is the practical alternative: call it
through the Apify API with a JSON input and read the rows from the dataset.

#### Can I export the results to CSV or Excel?

Yes. Every run stores the rows in an Apify dataset, which you can download as JSON,
CSV, Excel, XML or HTML, or read through the API and integrations.

#### Which countries does the scraper support?

The Netherlands, Germany, Belgium, France, Italy, Spain, Austria, Poland and Sweden.
Set `market` to `nl`, `de`, `be`, `fr`, `it`, `es`, `at`, `pl` or `se`.

#### Are these verified vehicle specifications or final sale prices?

They are the specifications and asking prices shown in public advertisements.
The scraper preserves the source information and does not independently verify
the condition, ownership, sale outcome or final transaction price of a vehicle.

# 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/AihEafywsEAeTdwYy/openapi.json