# AutoScout24 Scraper $0.8💰 Cars + Dealer Data (`corvuslab/autoscout24-scraper`) Actor

From 💰$0.8/1K. Scrape car listings from AutoScout24 across 8 European markets, with full vehicle specs, pricing, price-rating labels and dealer contacts. Get back clean JSON with 80+ fields per vehicle.
Useful for car dealers, market analysts, valuation pipelines, lead generation and many more.

- **URL**: https://apify.com/corvuslab/autoscout24-scraper.md
- **Developed by:** [Corvuslab](https://apify.com/corvuslab) (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

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

Extract car listings from **AutoScout24**, Europe's largest vehicle marketplace, across
**8 markets** — Germany, Austria, Belgium, France, Italy, Netherlands, Spain and Luxembourg.

Every record comes back as clean, typed JSON: full vehicle specification, price with
AutoScout24's own price rating, seller identity and phone number, GPS coordinates,
equipment list and the complete seller description.

---

### What you get

- **🌍 8-market coverage** — Germany, Austria, Belgium, France, Italy, Netherlands, Spain
  and Luxembourg on one codebase. Each country is searched separately and the results are
  merged and de-duplicated into a single dataset.

- **🏷️ AutoScout24 price-rating labels** — every listing carries AutoScout24's own price
  classification (`top-price`, `good-price`, `fair-price`, `somewhat-expensive`,
  `increased-price`, `high-price`) alongside the numeric price, so you can spot underpriced
  stock without building your own valuation model.

- **📞 Dealer contacts** — company name, contact person, phone number, dealer profile URL
  and the dealer's star rating and review count.

- **🔧 80+ structured fields** — power in kW and HP, drivetrain, gears, cylinders,
  displacement, body colour, paint type, upholstery, equipment list, emission class, fuel
  consumption, previous owners, service history and accident status.

- **📍 Geo data** — country, city, ZIP, street and latitude/longitude on every record, ready
  to plot or to join against your own territory data.

- **♻️ Incremental mode** — scheduled runs emit only listings that are new, changed or gone
  since the last run. Unchanged cars are skipped before any detail page is fetched, so a
  quiet run is both fast and cheap.

- **📌 Change classification** — each record carries a `changeType` of `NEW` / `UPDATED` /
  `REAPPEARED` / `EXPIRED`, so a diff dashboard needs no extra bookkeeping on your side.

- **🔔 Notifications** — Slack, Discord, Telegram and custom webhook alerts when a run
  finishes. Combine with incremental mode to be pinged only when inventory or pricing
  actually moves.

- **📋 Detail enrichment** — two-stage scraping: paginate the search first, then pull each
  listing's full detail payload. One toggle (`includeDetails`) controls the depth, so you
  can trade completeness for speed and cost.

- **📦 Compact mode** — core fields only, for AI agents and MCP clients that pay per token.
  Pair it with `excludeEmptyFields` to drop nulls and empty arrays entirely.

- **✂️ Description control** — pick a single description representation with
  `descriptionFormat` (`text` / `html` / `markdown`) and cap its length with
  `descriptionMaxLength` to keep prompt cost and dataset size predictable.

- **🔗 Paste-a-URL** — build the search on autoscout24.com and paste the URL straight in.
  Any search URL works, and several can run in one go.

- **📤 Export anywhere** — download as JSON, CSV, Excel or XML from the Apify Console, or
  stream it live through the Apify API and integrations.

The scraper reads AutoScout24's own structured page data rather than scraping rendered
HTML, so fields stay accurate and the output does not break when the site restyles.

---

### Input

Either fill in the filters, or paste search URLs straight from your browser.

```json
{
  "make": "BMW",
  "model": "3-series",
  "countries": ["DE", "AT"],
  "condition": "used",
  "priceFrom": 5000,
  "priceTo": 25000,
  "yearFrom": 2018,
  "mileageTo": 150000,
  "fuelTypes": ["diesel"],
  "transmission": "automatic",
  "bodyTypes": ["station-wagon"],
  "sortBy": "newest",
  "maxResults": 100,
  "includeDetails": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

**Make and model** accept the names you already know — `BMW`, `VW`, `mercedes-benz` —
and both family and specific names for the model: `3-series` and `3 Series` both work,
as do `c-class`, `golf` and `320`. Get it wrong and the run stops immediately with the
list of valid models, instead of quietly returning the wrong cars.

**Paste a URL** instead if you prefer to build the search on autoscout24.com:

```json
{
  "searchUrls": ["https://www.autoscout24.com/lst/porsche/911?atype=C&cy=A&sort=price&desc=1"],
  "maxResults": 50
}
```

***

### Output

One row per listing. Unavailable data points are returned as `null`, never omitted,
so the shape is stable across every run.

```json
{
  "listingId": "b22d05a0-a5c4-4f6f-9c5c-d16736186a4a",
  "title": "BMW 330 d Touring Steptronic Sport Line+LED+AHK+PDC",
  "url": "https://www.autoscout24.com/offers/bmw-330-d-touring-…",
  "make": "BMW",
  "model": "330",
  "modelGroup": "3 Series",
  "variant": "Touring",
  "motorType": "330d",
  "bodyType": "Station Wagon",
  "condition": "Used",
  "mileageKm": 130469,
  "firstRegistration": "2018-10-01",
  "fuelType": "Diesel",
  "transmission": "Automatic",
  "gears": 8,
  "powerKw": 190,
  "powerHp": 258,
  "engineDisplacementCcm": 2993,
  "cylinders": 6,
  "driveTrain": "Rear Wheel Drive",
  "bodyColor": "Blue",
  "paintType": "Metallic",
  "upholstery": "Cloth",
  "numberOfSeats": 5,
  "numberOfDoors": 5,
  "price": 18990,
  "priceFormatted": "€ 18,990",
  "currency": "EUR",
  "priceEvaluation": "top-price",
  "priceNegotiable": false,
  "vatDeductible": false,
  "sellerType": "Dealer",
  "sellerName": "Kamux Auto GmbH",
  "sellerContact": "Ihr Verkaufsteam",
  "sellerPhone": "+492421480508100",
  "dealerUrl": "https://www.autoscout24.com/dealerinfo/kamux-auto-gmbh-dueren?atype=C",
  "sellerRatingStars": 4.0,
  "sellerRatingCount": 11,
  "country": "DE",
  "city": "Düren",
  "zip": "52351",
  "street": "Rudolf-Diesel-Straße 5",
  "latitude": 50.78089,
  "longitude": 6.50913,
  "imageCount": 46,
  "images": ["https://prod.pictures.autoscout24.net/listing-images/…/1280x960.webp"],
  "equipment": ["Panorama roof", "Navigation system", "Trailer hitch", "…"],
  "emissionClass": "Euro 6",
  "fuelConsumption": "4.1 l/100 km (comb.)",
  "fuelConsumptionL100km": 4.1,
  "previousOwners": 2,
  "hasServiceHistory": false,
  "hadAccident": false,
  "nextInspection": "11/2027",
  "createdAt": "2026-04-21T14:47:24.521Z",
  "scrapedAt": "2026-07-25T11:57:21.849Z",
  "source": "autoscout24.com"
}
```

Export as JSON, CSV, Excel or XML, stream it from the API, or push it onward with any
Apify integration.

#### Compact mode

Set `compact: true` to get just the 20 fields that matter for triage — ideal when an
LLM or agent is reading the output and you are paying per token.

***

### Incremental mode — turn it into a monitor

Set `incrementalMode: true` and schedule the run. The scraper remembers every listing
between runs and reports only the deltas:

| `changeType` | Meaning |
| --- | --- |
| `NEW` | Listing appeared for the first time |
| `UPDATED` | Price, mileage, title, rating or photo count changed |
| `REAPPEARED` | A listing that had disappeared came back |
| `EXPIRED` | A listing that was there last run is gone — sold or withdrawn |

Unchanged listings are skipped entirely: they cost you nothing and are not even fetched.
A real example from a 35-car search — the second run emitted **2 records instead of 35**.

Change detection is decided from the search page, before any detail page is requested,
so a quiet run is fast *and* cheap. Set `skipReposts: true` to also suppress vehicles
that a dealer deleted and re-listed under a fresh ID.

> `EXPIRED` needs a complete pass over the search, so it is reported only on runs that
> were not cut short by `maxResults`. The run log tells you when this happens.

***

### Notifications

Fill in any of `slackWebhookUrl`, `discordWebhookUrl`, `telegramToken` + `telegramChatId`
or `webhookUrl` to get a summary when the run finishes. Combine with
`notifyOnlyChanges: true` and incremental mode to be pinged only when something actually
moved. A failing notification never fails the run.

***

### Use cases

- **Competitive pricing intelligence** — pull every rival listing for the models you stock,
  join it against your own inventory and see where you are over- or under-priced. The
  `priceEvaluation` label gives you AutoScout24's own verdict on each car for free.

- **Cross-border arbitrage** — the same model is rarely priced the same in Germany and
  Italy. All eight markets are quoted in EUR, so a single run gives you a directly
  comparable price spread without any FX handling.

- **Inventory and stock monitoring** — run it on a schedule with `incrementalMode` to watch
  a competitor's dealer stock and get told the moment a car is added, repriced or sold. The
  `EXPIRED` change type is a sell-through signal you cannot get from a one-off scrape.

- **Residual value and depreciation modelling** — mileage, first registration, power,
  equipment and price on tens of thousands of comparable cars is the raw material for a
  valuation curve. Add `previousOwners`, `hadAccident` and `hasServiceHistory` to control
  for condition.

- **Lead generation** — every dealer record carries company name, contact person, phone
  number, profile URL and star rating, filterable by country, city or brand specialisation.

- **Buyer alerts** — a narrow saved search plus `incrementalMode` and `notifyOnlyChanges`
  pings your Slack, Discord or Telegram only when a car matching your brief actually
  appears, instead of re-sending the same results every morning.

- **AI agents and LLM pipelines** — `compact` mode plus `excludeEmptyFields` and
  `descriptionMaxLength` produce a small, uniform payload that fits in a prompt without
  burning tokens on nulls and boilerplate.

***

### Good to know

- **Use residential proxies.** AutoScout24 challenges datacenter IPs, and a challenged
  detail page comes back with empty fields rather than an error. The default proxy setting
  already selects residential.
- **4,000 listings per search is AutoScout24's own limit**, not this Actor's. To go past it,
  narrow the filters (by price band, year or body type) or add more countries — each country
  is searched separately and gets its own 4,000.
- **Set `includeDetails: false`** for a fast, cheap sweep: you still get title, price, price
  rating, mileage, registration, fuel, gearbox, seller and location, just without the
  description, equipment and detailed specification.
- **Prices are in EUR** across all eight markets.

***

### FAQ

**How many listings can I get in one run?**
Set `maxResults` to whatever you need. The practical ceiling is AutoScout24's own: it stops
paginating a single search after a few thousand results, however you sort it. Each country
you select is a separate search with its own ceiling, so adding markets or narrowing by
price band, year or body type multiplies what you can reach. The run log reports how many
listings are available and how many pages are reachable for every search it starts.

**Do I need a proxy?**
Yes — use residential. AutoScout24 challenges datacenter IPs, and a challenged detail page
comes back with empty fields rather than a visible error, so you would get records that look
fine but are missing the description, equipment and GPS. The default input already selects
Apify Proxy with the residential group.

**Can I run it on a schedule?**
That is what it is built for. Add an Apify schedule, set `incrementalMode: true`, and each
run reports only what changed since the last one. State is kept between runs automatically;
set `stateKey` if you want several schedules to track separate searches independently.

**Does AutoScout24 have an official API?**
Not a public one for listing search. This Actor reads the structured data the site's own
front end uses, which is why the output is typed and stable rather than reverse-engineered
from rendered HTML.

**Which countries and currencies are covered?**
Germany, Austria, Belgium, France, Italy, Netherlands, Spain and Luxembourg. Every price is
returned in EUR, so cross-market comparisons need no conversion.

**Can I use my own AutoScout24 search URL?**
Yes. Build the search in your browser, paste the URL into `searchUrls`, and the Actor takes
it from there. Multiple URLs run in one go, and they override the filter fields.

**How do I get the data out?**
Download as JSON, CSV, Excel or XML from the Console, pull it from the Apify API, or push it
onward with any Apify integration. For your own systems, set `webhookUrl` to receive a JSON
`POST` with the run summary as soon as it finishes.

**Why are some fields `null`?**
Because the seller did not fill them in. Every field is always present, with `null` where
there is no data, so the record shape never changes between runs. Set `excludeEmptyFields:
true` if you would rather have them dropped. Note that `includeDetails: false` also leaves
the detail-only fields empty by design.

**Is scraping AutoScout24 legal?**
The Actor only collects data AutoScout24 publishes openly, without logging in. Listings can
still contain personal data about private sellers — see [Legal](#legal) below.

***

### Legal

This Actor collects data that AutoScout24 publishes openly, without logging in. Listings
can still contain personal information about private sellers, and you are responsible for
handling it lawfully — under GDPR that means having a legitimate basis for collecting and
storing it. Use the data in line with AutoScout24's terms and your local law.

# Actor input Schema

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

Car manufacturer, e.g. `BMW`, `Mercedes-Benz`, `volkswagen`. Matching is case- and dash-insensitive.

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

Model or model line, e.g. `320`, `3-series`, `golf`, `c-class`. Requires **Make**. Matching is case- and dash-insensitive; unknown values fail fast with the list of valid models.

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

Markets to search. Each country is searched separately and the results are merged and de-duplicated, so N countries lift the 4,000-listing cap to N × 4,000.

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

Limit results by vehicle condition. `all` includes both new and used listings.

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

Minimum price in EUR.

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

Maximum price in EUR.

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

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

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

Latest first-registration year, e.g. 2024.

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

Minimum mileage in kilometres.

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

Maximum mileage in kilometres.

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

Filter by fuel type. Leave empty for any.

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

Filter by transmission type.

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

Filter by body type. Leave empty for any.

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

Restrict to dealer or private listings.

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

Result ordering. `newest` is the right choice for monitoring — the freshest listings arrive on page 1.

## `sortDescending` (type: `boolean`):

Reverse the sort order. Ignored for `Best results` and `Newest offers first`.

## `searchUrls` (type: `array`):

Paste AutoScout24 search URLs (e.g. from your browser after applying filters). When set, every filter above is ignored and these URLs are paginated instead.

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

Maximum total listings to return. `0` means unlimited. AutoScout24 itself never serves more than 4,000 listings per search, so narrow your filters or add countries to go beyond that.

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

Fetch each listing's detail page to add description, full equipment list, power, colour, doors/seats, GPS coordinates, emission class, consumption and owner history. Slower and needs one extra request per listing, but roughly triples the number of populated fields.

## `descriptionFormat` (type: `string`):

How the seller's description is rendered. `all` fills `description` (plain text), `descriptionHtml` and `descriptionMarkdown`.

## `descriptionMaxLength` (type: `integer`):

Truncate every description variant to N characters. `0` disables truncation.

## `compact` (type: `boolean`):

Emit only the core identification, price and location fields. Handy for AI agents and MCP clients that pay per token.

## `excludeEmptyFields` (type: `boolean`):

Drop `null` and empty fields from each record instead of always returning the full field set.

## `incrementalMode` (type: `boolean`):

Remember listings between runs and emit only what changed — `NEW`, `UPDATED`, `REAPPEARED` and `EXPIRED`. Unchanged listings are skipped entirely, which cuts both scraping time and per-result cost on recurring monitoring runs. The first run builds the baseline and emits everything.

## `stateKey` (type: `string`):

Stable name for the tracked search. Leave empty to derive it from the search filters. Set it explicitly if you tweak filters but want to keep the same history.

## `skipReposts` (type: `boolean`):

Detect vehicles that were deleted and re-listed under a new listing ID, and drop them instead of reporting them as `NEW`. Requires incremental mode.

## `webhookUrl` (type: `string`):

Receives a JSON `POST` with `{ metadata, items }` when the run finishes.

## `webhookHeaders` (type: `object`):

Extra HTTP headers for the webhook, e.g. `{ "Authorization": "Bearer …" }`.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

Discord incoming-webhook URL.

## `telegramToken` (type: `string`):

Bot token from @BotFather.

## `telegramChatId` (type: `string`):

Target chat or channel ID, e.g. `-100123456789`.

## `notificationLimit` (type: `integer`):

How many listings to include in a chat notification.

## `notifyOnlyChanges` (type: `boolean`):

With incremental mode on, only notify when there is at least one `NEW` or `UPDATED` listing.

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

Proxy used for all requests. Residential recommended — AutoScout24 challenges datacenter IPs on detail pages, which silently returns empty detail fields.

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

Parallel detail-page requests. Lower this if you see blocks or empty detail fields.

## Actor input object example

```json
{
  "make": "BMW",
  "model": "3-series",
  "countries": [
    "DE"
  ],
  "condition": "all",
  "sellerType": "any",
  "sortBy": "standard",
  "sortDescending": false,
  "searchUrls": [],
  "maxResults": 100,
  "includeDetails": true,
  "descriptionFormat": "all",
  "descriptionMaxLength": 0,
  "compact": false,
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "skipReposts": false,
  "notificationLimit": 5,
  "notifyOnlyChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 8
}
```

# Actor output Schema

## `overview` (type: `string`):

Scraped listings as a readable table.

## `changes` (type: `string`):

Incremental-mode change log for this run.

## `allFields` (type: `string`):

Complete dataset with every field.

# 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 = {
    "searchUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoScout24 Scraper $0.8💰 Cars + Dealer Data",
        "description": "From 💰$0.8/1K. Scrape car listings from AutoScout24 across 8 European markets, with full vehicle specs, pricing, price-rating labels and dealer contacts. Get back clean JSON with 80+ fields per vehicle. \nUseful for car dealers, market analysts, valuation pipelines, lead generation and many more.",
        "version": "0.1",
        "x-build-id": "i3xATCLJMbV7oscXG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/corvuslab~autoscout24-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-corvuslab-autoscout24-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/corvuslab~autoscout24-scraper/runs": {
            "post": {
                "operationId": "runs-sync-corvuslab-autoscout24-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/corvuslab~autoscout24-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-corvuslab-autoscout24-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "make": {
                        "title": "🏭 Make",
                        "type": "string",
                        "description": "Car manufacturer, e.g. `BMW`, `Mercedes-Benz`, `volkswagen`. Matching is case- and dash-insensitive."
                    },
                    "model": {
                        "title": "🚗 Model",
                        "type": "string",
                        "description": "Model or model line, e.g. `320`, `3-series`, `golf`, `c-class`. Requires **Make**. Matching is case- and dash-insensitive; unknown values fail fast with the list of valid models."
                    },
                    "countries": {
                        "title": "🌍 Countries",
                        "type": "array",
                        "description": "Markets to search. Each country is searched separately and the results are merged and de-duplicated, so N countries lift the 4,000-listing cap to N × 4,000.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "DE",
                                "AT",
                                "BE",
                                "FR",
                                "IT",
                                "NL",
                                "ES",
                                "LU"
                            ],
                            "enumTitles": [
                                "Germany",
                                "Austria",
                                "Belgium",
                                "France",
                                "Italy",
                                "Netherlands",
                                "Spain",
                                "Luxembourg"
                            ]
                        },
                        "default": [
                            "DE"
                        ]
                    },
                    "condition": {
                        "title": "✨ Condition",
                        "enum": [
                            "all",
                            "new",
                            "used"
                        ],
                        "type": "string",
                        "description": "Limit results by vehicle condition. `all` includes both new and used listings.",
                        "default": "all"
                    },
                    "priceFrom": {
                        "title": "💰 Price from (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in EUR."
                    },
                    "priceTo": {
                        "title": "💰 Price to (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in EUR."
                    },
                    "yearFrom": {
                        "title": "📅 First registration from",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Earliest first-registration year, e.g. 2018."
                    },
                    "yearTo": {
                        "title": "📅 First registration to",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Latest first-registration year, e.g. 2024."
                    },
                    "mileageFrom": {
                        "title": "🛣️ Mileage from (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum mileage in kilometres."
                    },
                    "mileageTo": {
                        "title": "🛣️ Mileage to (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum mileage in kilometres."
                    },
                    "fuelTypes": {
                        "title": "⛽ Fuel types",
                        "type": "array",
                        "description": "Filter by fuel type. Leave empty for any.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "petrol",
                                "diesel",
                                "electric",
                                "hybrid-petrol",
                                "hybrid-diesel",
                                "lpg",
                                "cng",
                                "hydrogen",
                                "ethanol",
                                "other"
                            ],
                            "enumTitles": [
                                "Petrol / Gasoline",
                                "Diesel",
                                "Electric",
                                "Hybrid (electric/petrol)",
                                "Hybrid (electric/diesel)",
                                "LPG",
                                "CNG",
                                "Hydrogen",
                                "Ethanol",
                                "Other"
                            ]
                        }
                    },
                    "transmission": {
                        "title": "⚙️ Transmission",
                        "enum": [
                            "automatic",
                            "manual",
                            "semi-automatic"
                        ],
                        "type": "string",
                        "description": "Filter by transmission type."
                    },
                    "bodyTypes": {
                        "title": "🚙 Body types",
                        "type": "array",
                        "description": "Filter by body type. Leave empty for any.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "compact",
                                "convertible",
                                "coupe",
                                "suv",
                                "station-wagon",
                                "sedan",
                                "van",
                                "transporter",
                                "other"
                            ],
                            "enumTitles": [
                                "Compact",
                                "Convertible",
                                "Coupe",
                                "SUV / Off-Road / Pick-Up",
                                "Station Wagon",
                                "Sedan",
                                "Van",
                                "Transporter",
                                "Other"
                            ]
                        }
                    },
                    "sellerType": {
                        "title": "👤 Seller type",
                        "enum": [
                            "any",
                            "dealer",
                            "private"
                        ],
                        "type": "string",
                        "description": "Restrict to dealer or private listings.",
                        "default": "any"
                    },
                    "sortBy": {
                        "title": "🔀 Sort by",
                        "enum": [
                            "standard",
                            "newest",
                            "price",
                            "mileage",
                            "year",
                            "power"
                        ],
                        "type": "string",
                        "description": "Result ordering. `newest` is the right choice for monitoring — the freshest listings arrive on page 1.",
                        "default": "standard"
                    },
                    "sortDescending": {
                        "title": "🔽 Sort descending",
                        "type": "boolean",
                        "description": "Reverse the sort order. Ignored for `Best results` and `Newest offers first`.",
                        "default": false
                    },
                    "searchUrls": {
                        "title": "🔗 Search URLs",
                        "type": "array",
                        "description": "Paste AutoScout24 search URLs (e.g. from your browser after applying filters). When set, every filter above is ignored and these URLs are paginated instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "💯 Max results",
                        "minimum": 0,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum total listings to return. `0` means unlimited. AutoScout24 itself never serves more than 4,000 listings per search, so narrow your filters or add countries to go beyond that.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "📋 Include listing details",
                        "type": "boolean",
                        "description": "Fetch each listing's detail page to add description, full equipment list, power, colour, doors/seats, GPS coordinates, emission class, consumption and owner history. Slower and needs one extra request per listing, but roughly triples the number of populated fields.",
                        "default": true
                    },
                    "descriptionFormat": {
                        "title": "📝 Description format",
                        "enum": [
                            "all",
                            "text",
                            "html",
                            "markdown"
                        ],
                        "type": "string",
                        "description": "How the seller's description is rendered. `all` fills `description` (plain text), `descriptionHtml` and `descriptionMarkdown`.",
                        "default": "all"
                    },
                    "descriptionMaxLength": {
                        "title": "✂️ Description max length",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Truncate every description variant to N characters. `0` disables truncation.",
                        "default": 0
                    },
                    "compact": {
                        "title": "📦 Compact records",
                        "type": "boolean",
                        "description": "Emit only the core identification, price and location fields. Handy for AI agents and MCP clients that pay per token.",
                        "default": false
                    },
                    "excludeEmptyFields": {
                        "title": "🧹 Exclude empty fields",
                        "type": "boolean",
                        "description": "Drop `null` and empty fields from each record instead of always returning the full field set.",
                        "default": false
                    },
                    "incrementalMode": {
                        "title": "♻️ Incremental mode",
                        "type": "boolean",
                        "description": "Remember listings between runs and emit only what changed — `NEW`, `UPDATED`, `REAPPEARED` and `EXPIRED`. Unchanged listings are skipped entirely, which cuts both scraping time and per-result cost on recurring monitoring runs. The first run builds the baseline and emits everything.",
                        "default": false
                    },
                    "stateKey": {
                        "title": "🔑 State key",
                        "type": "string",
                        "description": "Stable name for the tracked search. Leave empty to derive it from the search filters. Set it explicitly if you tweak filters but want to keep the same history."
                    },
                    "skipReposts": {
                        "title": "🚫 Skip reposts",
                        "type": "boolean",
                        "description": "Detect vehicles that were deleted and re-listed under a new listing ID, and drop them instead of reporting them as `NEW`. Requires incremental mode.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "🪝 Webhook URL",
                        "type": "string",
                        "description": "Receives a JSON `POST` with `{ metadata, items }` when the run finishes."
                    },
                    "webhookHeaders": {
                        "title": "🧾 Webhook headers",
                        "type": "object",
                        "description": "Extra HTTP headers for the webhook, e.g. `{ \"Authorization\": \"Bearer …\" }`."
                    },
                    "slackWebhookUrl": {
                        "title": "💼 Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming-webhook URL."
                    },
                    "discordWebhookUrl": {
                        "title": "🎮 Discord webhook URL",
                        "type": "string",
                        "description": "Discord incoming-webhook URL."
                    },
                    "telegramToken": {
                        "title": "✈️ Telegram bot token",
                        "type": "string",
                        "description": "Bot token from @BotFather."
                    },
                    "telegramChatId": {
                        "title": "💬 Telegram chat ID",
                        "type": "string",
                        "description": "Target chat or channel ID, e.g. `-100123456789`."
                    },
                    "notificationLimit": {
                        "title": "📊 Listings per notification",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many listings to include in a chat notification.",
                        "default": 5
                    },
                    "notifyOnlyChanges": {
                        "title": "🔄 Notify only on changes",
                        "type": "boolean",
                        "description": "With incremental mode on, only notify when there is at least one `NEW` or `UPDATED` listing.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "🛡️ Proxy Configuration",
                        "type": "object",
                        "description": "Proxy used for all requests. Residential recommended — AutoScout24 challenges datacenter IPs on detail pages, which silently returns empty detail fields."
                    },
                    "maxConcurrency": {
                        "title": "🚦 Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Parallel detail-page requests. Lower this if you see blocks or empty detail fields.",
                        "default": 8
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```