# AutoScout24 Scraper ($0.47/1K): Cars, Prices, Dealers (`tsutseisoftware/autoscout24-scraper`) Actor

Scrape AutoScout24 in 8 countries by make, model and the website's filters, or from any search URL. Price, price rating, mileage, registration, fuel, power, place, dealer; details, deal score, whole searches over 4,000 cars, dealer stock, monitoring of new, cheaper and sold cars, alerts.

- **URL**: https://apify.com/tsutseisoftware/autoscout24-scraper.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.42 / 1,000 listings

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/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: Cars, Prices & Dealers in 8 Countries

Scrape **AutoScout24**, Europe's largest car marketplace, in **Germany, Austria, Italy, France, the Netherlands, Spain, Belgium and Luxembourg**. Search by make and model with the website's own filters, or paste any search or listing URL from any AutoScout24 website. You get price, AutoScout24's price rating, mileage, first registration, fuel, transmission, power, place and dealer on every row, and optionally the full details: description, equipment, previous owners, accident and service history, warranty, net price and VAT, exact place and listing date.

**$0.47 per 1 000 listings ($0.42 on Gold plans), $0.51 with full details. No extra platform costs.**

### Why use this AutoScout24 scraper?

- 🇪🇺 **All eight AutoScout24 countries in one run**, or just one. Labels in English or in the language of any AutoScout24 website (.de, .it, .fr, .nl, .es, .at, .pl, .cz...).
- 🔎 **The website's own filters:** make and model, price, first registration, mileage, power, fuel, transmission, body type, condition (new, used, demonstration...), dealer or private seller, postal code with radius, listed in the last N days, and sorting (newest first, price, mileage, registration, power, distance).
- 📈 **Whole searches, not just the first 4 000.** AutoScout24 shows at most 4 000 listings of a search; bigger searches are read in full automatically. Get every Golf in Germany, not a fifth of them.
- 💸 **Two price signals on every car:** AutoScout24's own **price rating** (top, good, fair price...) and our **deal score** against comparable cars of the run (same make, model and fuel, similar age and mileage): the usual price, the difference in % and a score from 0 to 100. Filter by "at least 10 % below the usual price" or by price rating.
- 🏪 **Dealer stock:** read the whole stock of any dealer by its ID, watch competitors, and leave your own dealership out with **Exclude dealers**. Dealer name, rating, address and page on every dealer row.
- 📬 **Monitoring for scheduled runs:** only new cars and cars whose price changed come back, with the previous price and the change in %. Ask for **only price drops**, for cars that were **sold or taken down** (with how many days they were listed), and spot cars a dealer **relisted** under a new ID.
- 🔔 **Alerts:** Telegram, Slack, Discord, WhatsApp or your own webhook (Zapier, Make, n8n) after each run.
- 📊 **Free market summary** (SUMMARY record): price, mileage and age quartiles for every make and model, listings by country, seller type, fuel and price rating.
- 💱 **Prices in your currency:** **Convert prices to** USD, GBP, CHF, CZK, PLN and more (daily ECB rates).
- 🧾 **Clean, flat output** ready for Excel and CSV: numbers as numbers (`price`, `mileageKm`, `powerKw`, `year`), normalised `fuelType` and `transmission` in every language, ISO dates. Compact output and "no empty fields" for small exports.
- 🔒 **Privacy first:** private sellers' names, streets and IDs are never returned, and their place only to about 1 km; e-mails and phone numbers are removed from descriptions. Dealer phone numbers only with the paid option.

### What data can you get?

| Group | Fields |
|---|---|
| Vehicle | `id`, `url`, `title`, `make`, `model`, `modelVersion`, `variant`, `vehicleType`, `offerType`, `mileageKm`, `firstRegistration`, `year`, `fuelType`, `fuel`, `transmission`, `powerKw`, `powerHp`, `engineCcm`, `fuelConsumption`, `fuelConsumptionUnit`, `co2Emission`, `isDamaged` |
| Price | `price`, `currency`, `priceRating`, `priceConverted`, `convertedCurrency` |
| Deal | `comparableCount`, `comparableMedianPrice`, `priceVsMedianPercent`, `dealScore` |
| Place | `country`, `zip`, `city`, `street` (dealers); with details `latitude`, `longitude` |
| Seller | `sellerType`, `sellerName`, `sellerId`, `sellerRating`, `sellerRatingCount`, `sellerUrl` (dealers only) |
| Photos | `imageUrl`, `images` (1280×960), `imageCount` |
| Details | `description`, `equipment`, `bodyType`, `color`, `paintType`, `doors`, `seats`, `previousOwners`, `hadAccident`, `hasFullServiceHistory`, `nonSmoking`, `warranty`, `netPrice`, `vatRate`, `isVatDeductible`, `driveTrain`, `gears`, `cylinders`, `weightKg`, `emissionClass`, `electricRangeKm`, `upholstery`, `offerReference`, `listedAt` |
| Dealer contacts (option) | `dealerPhones`, `dealerWhatsapp`, `dealerContactPerson`, `dealerWebsite` |
| Search | `domain`, `searchLabel`, `searchUrl`, `position`, `isSponsored`, `resultType` |
| Monitoring | `changeType`, `changedFields`, `previousPrice`, `priceChange`, `priceChangePercent`, `firstSeenAt`, `removedAt`, `daysListed`, `isRepost`, `repostOf` |

Measured on 20 Skoda Octavia listings in Germany (13 Nov 2026): price, mileage, fuel, transmission, power and town on 100 % of rows, photos on 95 %, first registration on 90 % (new cars have none), AutoScout24's price rating on 85 %, dealer rating on 85 %. With details (40 BMW 3 Series): description 97 %, equipment and listing date 100 %, previous owners 75 %, emission class 72 %, warranty 15 %; fuel consumption 65 % and CO₂ 50 % of 20 BMW 3 Series with details.

### How to scrape AutoScout24

1. Enter one or more lines in **Make and model** (e.g. `Skoda Octavia`, `BMW 3 Series`, `Tesla`), or paste search URLs from the browser into **AutoScout24 URLs**.
2. Choose the **Countries** and, if you like, the website's filters (price, year, mileage, fuel...).
3. Turn on **Add listing details** if you need descriptions, equipment and the car's history.
4. Click **Start**. Download the results as Excel, CSV or JSON, or get them through the API.
5. For alerts, schedule the run (e.g. every hour), turn on **Monitoring: only new or changed listings** and add a Telegram, Slack, Discord or WhatsApp channel.

### Use cases

#### Used Skoda Octavia diesels in Germany and Austria, 2018 or newer

```json
{
  "searches": ["Skoda Octavia"],
  "countries": ["DE", "AT"],
  "fuelTypes": ["diesel"],
  "yearFrom": 2018,
  "mileageTo": 150000,
  "maxItems": 500
}
```

#### Deals: at least 10 % below comparable cars, to Telegram every hour

```json
{
  "searches": ["Volkswagen Golf", "Audi A3"],
  "countries": ["DE"],
  "priceTo": 20000,
  "maxPriceVsMedianPercent": -10,
  "onlyNewOrChanged": true,
  "monitoringKey": "golf-a3-deals",
  "telegramBotToken": "123456:ABC...",
  "telegramChatId": "123456789",
  "maxItems": 0
}
```

#### Watch a competitor's stock: new cars, price drops and sold cars

```json
{
  "dealerIds": ["42667936"],
  "countries": [],
  "onlyNewOrChanged": true,
  "includeRemovedListings": true,
  "monitoringKey": "competitor-42667936",
  "maxItems": 0
}
```

#### The whole market of one model for a price analysis

```json
{
  "searches": ["Volkswagen Golf"],
  "countries": ["DE"],
  "offerTypes": ["used"],
  "maxItems": 0
}
```

Read the free SUMMARY record for price, mileage and age quartiles, and the `priceRating` and `dealScore` columns for the cheapest cars. Searches over 4 000 listings are read in full.

#### Cars around a postal code, private sellers only, with details

```json
{
  "searches": ["Toyota Yaris"],
  "countries": ["DE"],
  "zipCode": "10115",
  "radiusKm": 50,
  "sellerType": "private",
  "includeDetails": true,
  "onlyAccidentFree": true,
  "maxItems": 100
}
```

#### A search copied from the browser, and single listings

```json
{
  "startUrls": [
    { "url": "https://www.autoscout24.it/lst/fiat/500?fregfrom=2019" },
    { "url": "https://www.autoscout24.de/angebote/skoda-octavia-kombi-1-2-tsi-elegance-a6f3a05f-1494-4724-abc0-0caf23aed964" }
  ],
  "maxItems": 200
}
```

A search URL keeps all the filters you set on the website. Listing URLs are read with their details.

#### Deal score, explained

Each car is compared with comparable cars found in the same run: the same make, model and fuel, first registered at most a year apart, with a similar mileage. `comparableMedianPrice` is their median price, `priceVsMedianPercent` the difference (negative = cheaper) and `dealScore` 50 = the usual price, higher = cheaper. With too few comparable cars the fields are empty; bigger searches give more cars to compare with. `priceRating` is AutoScout24's own rating and is there on every rated car.

#### Monitoring mode, explained

With **Monitoring: only new or changed listings**, each run remembers the cars it saw (per **Monitoring key**) and returns only new cars and cars whose price, mileage or title changed. **Report sold and removed listings** returns cars of the previous run that are no longer on AutoScout24, with `removedAt` and `daysListed` (how long they were listed: days to sell). Unchanged cars are not returned and not charged; every page read is charged as a monitoring page.

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

| | Price |
|---|---|
| Listing | **$0.47 per 1 000** (Bronze $0.45, Silver $0.44, Gold and higher $0.42) |
| Add listing details | **+$0.04 per 1 000** (= $0.51 per 1 000 with details) |
| Add dealer phone numbers | +$0.50 per 1 000 listings that have them (dealers only) |
| Run start | $0.002 per run |
| Extra page | $0.10 per 1 000 pages read beyond what the saved listings explain (narrow filters, empty price ranges of a big search) |
| Monitoring page | $0.10 per 1 000 pages read in monitoring mode, and per sold/removed check |
| Notification | $0.001 per run that sent a notification |

Examples: 1 000 listings cost about **$0.47**, 1 000 listings with full details about **$0.51**. An hourly monitoring check of a search with 200 cars that finds 2 new ones costs about **$0.004**, about $2.80 a month. With the $5 of free monthly credit on the Apify free plan you get about **10 000 listings**.

Listings left out by your filters and unchanged listings in monitoring are never charged as listings. A filter that needs the details (**Description must contain**, **Max previous owners**, **Only accident-free**) can judge a car only after its details are read, so a car it leaves out is charged its details ($0.00004), not as a listing. If the saved listings don't cover a run's own cost (e.g. a search with no results), the difference is charged as extra pages; the log says how many. A normal run pays nothing more. You can set a **maximum cost per run**; the run then stops before it is spent.

### Input example

```json
{
  "searches": ["Skoda Octavia"],
  "countries": ["DE"],
  "sortBy": "newest",
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "a6f3a05f-1494-4724-abc0-0caf23aed964",
  "source": "autoscout24",
  "url": "https://www.autoscout24.com/offers/skoda-octavia-combi-1-2-tsi-elegance-a6f3a05f-1494-4724-abc0-0caf23aed964",
  "title": "Skoda Octavia Kombi 1.2 TSI Elegance - PDC hinten - Tempomat - D",
  "make": "Skoda",
  "model": "Octavia",
  "vehicleType": "car",
  "offerType": "used",
  "price": 8990,
  "currency": "EUR",
  "priceRating": "good-price",
  "mileageKm": 106800,
  "firstRegistration": "2014-09",
  "year": 2014,
  "fuelType": "petrol",
  "transmission": "manual",
  "powerKw": 77,
  "powerHp": 105,
  "engineCcm": 1197,
  "country": "DE",
  "zip": "96114",
  "city": "Hirschaid",
  "sellerType": "dealer",
  "sellerName": "Autohaus Kügel GmbH",
  "sellerId": "42667936",
  "sellerRating": 5,
  "sellerRatingCount": 9,
  "imageUrl": "https://prod.pictures.autoscout24.net/listing-images/a6f3a05f-1494-4724-abc0-0caf23aed964_9f3e83dd-58ce-4c58-914d-32fbc84911c2.jpg/1280x960.webp",
  "imageCount": 14,
  "comparableMedianPrice": 9900,
  "priceVsMedianPercent": -9.2,
  "dealScore": 55,
  "detailsIncluded": true,
  "bodyType": "Station Wagon",
  "color": "Brown",
  "previousOwners": 2,
  "hadAccident": false,
  "hasFullServiceHistory": true,
  "warranty": "12 months",
  "netPrice": 7555,
  "vatRate": 19,
  "emissionClass": "Euro 5",
  "listedAt": "2026-11-09T10:59:41.826Z",
  "searchLabel": "Skoda Octavia",
  "scrapedAt": "2026-11-13T20:07:54Z"
}
```

### Limitations

- **Countries:** the eight countries of AutoScout24's European marketplace. The Swiss AutoScout24 (.ch) is a separate website and is not covered.
- **Prices** are in euros as AutoScout24 shows them; `priceConverted` adds your currency.
- **Deal score** compares cars of the same run; a narrow search has fewer comparable cars, so more rows have it empty. AutoScout24's `priceRating` is always there when the website rates the car.
- **Sold or taken down:** AutoScout24 does not say whether a car was sold or only withdrawn; both come back as `removed`.
- **Views and saves** (`viewCount`, `favoriteCount`) are there only when the website shows them.
- **Sponsored listings** that the website mixes into the results are marked `isSponsored`; **Leave out sponsored listings** drops them.
- **Fuel consumption and CO₂** come mostly with details, when the seller gives them (WLTP values first).
- **Listing URLs** (read one by one) have no `priceRating` and no deal score: AutoScout24 shows its rating only in search results.
- No proxy is needed.

### For AI agents and API users

- Call the actor with the input above through the Apify API, the Apify MCP server or any integration; results are in the default dataset, the market summary in the `SUMMARY` record of the key-value store.
- For small answers use `"compact": true` and `"maxItems"`.
- Input errors (an unknown make or model, a filter that needs details, a postal code without one country) end the run with a message that says what to change.

### Troubleshooting

- **"AutoScout24 does not know the make or model"**: write it as the website does, e.g. `BMW 3 Series`, `Mercedes-Benz C 200`, `Volkswagen Golf`, or copy the search URL from the browser.
- **Fewer listings than on the website:** check **Max listings** (default 100) and **Max listings per search**. The status message says if a search was not read in full.
- **"AutoScout24 refused the requests"**: a page the website rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. Run it again later.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More classified-ad scrapers

The same deal score, monitoring and alerts for another classified-ad site:

- [Bazoš Scraper & New Ad Monitor](https://apify.com/tsutseisoftware/bazos-scraper): Bazoš.cz, .sk, .pl and .at: any section or search, deal score, car fields, new and cheaper ads with alerts
- [Facebook Marketplace Scraper](https://apify.com/tsutseisoftware/facebook-marketplace-scraper): any town, ZIP code or coordinates with a strict radius: price, place, seller, deal score, sold listings, alerts
- [Vinted Scraper](https://apify.com/tsutseisoftware/vinted-scraper): 24 Vinted country sites in one run: price, brand, size, condition in English, deal score, sold items, alerts
- [Kleinanzeigen Scraper & New Ad Monitor](https://apify.com/tsutseisoftware/kleinanzeigen-scraper): Germany's biggest classifieds: searches past 1,250 ads, deal score, vehicle and electronics fields, price check, new and cheaper ads with alerts
- [Craigslist Scraper](https://apify.com/tsutseisoftware/craigslist-scraper): any Craigslist site, a whole state or country in one run: up to 10,000 ads per search, deal score, removed ads, new ad alerts

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape AutoScout24?

It reads only publicly available data that AutoScout24 shows to any visitor, without logging in, at most 120 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. Make sure your use respects the website's terms and the law that applies to you. Private sellers' names and addresses are never returned (their place only to about 1 km), and e-mails and phone numbers are removed from descriptions. Dealer phone numbers and the dealer's contact person come only with **Add dealer phone numbers**; a contact person's name is personal data, so you are responsible for processing it lawfully (e.g. GDPR in the EU: a legitimate purpose, no spam, deletion on request). This actor is not affiliated with AutoScout24.

#### How is it different from other AutoScout24 scrapers?

It reads searches over the website's 4 000-listing limit in full, adds a deal score against comparable cars next to AutoScout24's own price rating, reads whole dealer stocks, reports sold cars with days to sell and relisted cars, sends alerts, and costs $0.47 per 1 000 listings ($0.42 on Gold), $0.51 with full details, with no extra platform costs.

#### Which websites and countries work?

Searches and listings from autoscout24.com, .de, .at, .it, .fr, .nl, .es, .be, .lu and the other AutoScout24 language versions (.pl, .cz, .ro, .hu...). The vehicles are in Germany, Austria, Italy, France, the Netherlands, Spain, Belgium and Luxembourg.

#### Can I get motorbikes, vans or caravans?

Yes, set **Vehicle type** to motorbikes, vans and transporters, or caravans and motorhomes. A motorbike or caravan make (Yamaha, Ducati, Hymer, Knaus...) searches its own vehicle type automatically.

#### Can I use it from an AI agent or through MCP?

Yes. The actor works with the Apify MCP server and API, and the compact output keeps agent answers short.

***

More scrapers from the same developer: [tsutseisoftware on Apify](https://apify.com/tsutseisoftware).

Also known as an AutoScout24 API, AutoScout24 car price tracker, used car price scraper, Gebrauchtwagen-Preise scraper or "auta z Německa" monitor.

# Changelog

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

# Actor input Schema

## `searches` (type: `array`):

One search per line: a make, or a make and a model as AutoScout24 names them ("Skoda Octavia", "BMW 3 Series", "Mercedes-Benz C 200", "Volkswagen Golf", "Tesla"). The filters below apply to every line.

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

Search pages copied from the browser on any AutoScout24 website (.de, .com, .it, .fr, .nl, .es, .at, .be, .lu...), with all their filters, e.g. https://www.autoscout24.de/lst/skoda/octavia?fregfrom=2018; and listing URLs (read with their details).

## `dealerIds` (type: `array`):

Read the whole stock of these dealers (the sellerId field of the output, e.g. 42667936). Combined with "Make and model", only those cars of each dealer.

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

Where the vehicles are. Empty = all eight countries of AutoScout24.

## `vehicleType` (type: `string`):

What kind of vehicles to search.

## `siteDomain` (type: `string`):

The AutoScout24 website the searches are read from: the language of labels such as fuel, body type and equipment, and the domain of the URLs. The listings are the same.

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

Lowest price.

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

Highest price.

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

Earliest year of the first registration.

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

Latest year of the first registration.

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

Lowest mileage.

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

Highest mileage.

## `powerFromKw` (type: `integer`):

Lowest engine power in kW.

## `powerToKw` (type: `integer`):

Highest engine power in kW.

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

Only these fuels. Empty = all.

## `transmissions` (type: `array`):

Empty = all.

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

Empty = all.

## `offerTypes` (type: `array`):

Empty = new and used.

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

Who sells the vehicle.

## `zipCode` (type: `string`):

Search around this postal code (needs exactly one country in "Countries"), e.g. 10115 for Berlin.

## `radiusKm` (type: `integer`):

With "Postal code": how far from it (10, 20, 50, 100, 150, 200, 250, 300 or 400 km; other values are rounded). Empty = 50 km.

## `listedWithinDays` (type: `integer`):

Only listings added in the last 1-7 or 14 days.

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

Order of the results. Newest first suits monitoring.

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

Maximum number of listings saved. You pay per saved listing. 0 = no limit.

## `maxItemsPerSearch` (type: `integer`):

Limit for each line of "Make and model", each URL and each dealer separately. 0 = no limit.

## `maxPagesPerSearch` (type: `integer`):

Read at most this many pages (20 listings each) of every search. 0 = no limit.

## `splitLargeSearches` (type: `boolean`):

The website shows at most 4,000 listings of one search. On = a bigger search is read in price ranges, so that all its listings are found (empty price ranges are charged as "Extra page"). Off = the first 4,000 only.

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

Description, equipment list, body type, colour, doors, seats, previous owners, accident and service history, warranty, net price and VAT, drive, emission class, exact place, listing date, all photos. Charged as "Listing details" ($0.04 per 1,000 listings, from 13 Nov 2026).

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

Cut descriptions to this many characters. 0 = whole.

## `includeDealerContacts` (type: `boolean`):

Dealers only (never private sellers): the dealer's phone numbers, WhatsApp and contact person; with details also the dealer's website. Charged as "Dealer contacts" ($0.50 per 1,000 listings that have them, from 13 Nov 2026). The contact person is personal data: you are responsible for using it lawfully (GDPR).

## `convertCurrency` (type: `string`):

Adds priceConverted in this currency (daily rates of the European Central Bank). Empty = prices in EUR only.

## `priceRatings` (type: `array`):

Only listings with these price ratings of AutoScout24 (e.g. top and good price). Empty = all.

## `maxPriceVsMedianPercent` (type: `integer`):

Only cars at most this many % above (or, negative, below) the usual price of comparable cars in the run, e.g. -10 = at least 10 % cheaper. Cars without enough comparable ones are left out.

## `minDealScore` (type: `integer`):

Only cars with at least this deal score (50 = the usual price of comparable cars).

## `titleKeywords` (type: `array`):

Keep listings whose title has one of these words (e.g. "RS", "4x4", "Scout").

## `excludeKeywords` (type: `array`):

Leave out listings whose title has one of these words (e.g. "defekt", "export").

## `excludeSponsored` (type: `boolean`):

Listings the website mixes into the results that are not the search's own results.

## `onlyWithPrice` (type: `boolean`):

Leave out listings with the price on request.

## `excludeSellers` (type: `array`):

Dealer names or IDs to leave out (e.g. your own dealership when you watch competitors).

## `descriptionKeywords` (type: `array`):

With "Add listing details": keep listings whose title or description has one of these words.

## `excludeDescriptionKeywords` (type: `array`):

With "Add listing details": leave out listings whose title or description has one of these words.

## `maxPreviousOwners` (type: `integer`):

With "Add listing details": only cars with at most this many previous owners (unknown = kept).

## `onlyAccidentFree` (type: `boolean`):

With "Add listing details": leave out cars the seller marks as having had an accident.

## `onlyNewOrChanged` (type: `boolean`):

Return new listings, and listings whose price, mileage or title changed (with previousPrice and the change in %).

## `monitoringKey` (type: `string`):

Name of the remembered state; use a different key for every saved search. Empty = "default".

## `includeRemovedListings` (type: `boolean`):

Listings of the previous run that are no longer on AutoScout24 (sold or taken down) are returned with changeType "removed", removedAt and daysListed. Each check is charged as "Monitoring page". Turned on for an existing monitoring key, it reports from the run after.

## `onlyPriceDrops` (type: `boolean`):

Of the changed listings, return only those whose price went down.

## `onlyNew` (type: `boolean`):

Return new listings only, not changed ones.

## `includeUnchanged` (type: `boolean`):

Return unchanged listings too (changeType "unchanged"; charged as listings).

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

A car the same dealer listed again under a new ID is marked isRepost; on = leave it out.

## `skipFirstRun` (type: `boolean`):

The first run only remembers the listings and returns nothing; later runs return what is new.

## `monitoringEarlyStop` (type: `boolean`):

With "Sort by" newest first: stop a search at the first page of listings that are all known (fast, cheap checks for new listings; changes deeper in the list are not seen).

## `ignoreChangesIn` (type: `array`):

Changes of these fields do not count.

## `resetMonitoring` (type: `boolean`):

Forget the remembered listings of this Monitoring key.

## `telegramBotToken` (type: `string`):

Token of your bot from @BotFather.

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

Chat to send to.

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

Incoming webhook (https://hooks.slack.com/...).

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

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

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

Any HTTPS URL (Zapier, Make, n8n, your server): receives the listings as JSON.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

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

How many listings the message lists.

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

No message after a run that saved nothing.

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

Only the main fields: title, make, model, price, rating, mileage, registration, fuel, power, place, seller, photo, deal score, URL.

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

Drop fields without a value from every row (smaller exports).

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

No proxy is needed (the default).

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searches": [
    "Skoda Octavia"
  ],
  "countries": [
    "DE"
  ],
  "vehicleType": "car",
  "siteDomain": "com",
  "sellerType": "all",
  "sortBy": "newest",
  "maxItems": 20,
  "maxItemsPerSearch": 0,
  "maxPagesPerSearch": 0,
  "splitLargeSearches": true,
  "includeDetails": false,
  "descriptionMaxLength": 0,
  "includeDealerContacts": false,
  "convertCurrency": "",
  "excludeSponsored": false,
  "onlyWithPrice": false,
  "onlyAccidentFree": false,
  "onlyNewOrChanged": false,
  "includeRemovedListings": false,
  "onlyPriceDrops": false,
  "onlyNew": false,
  "includeUnchanged": false,
  "skipReposts": false,
  "skipFirstRun": false,
  "monitoringEarlyStop": false,
  "resetMonitoring": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "compact": false,
  "excludeEmptyFields": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `listings` (type: `string`):

No description

## `summary` (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 = {
    "searches": [
        "Skoda Octavia"
    ],
    "countries": [
        "DE"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/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 = {
    "searches": ["Skoda Octavia"],
    "countries": ["DE"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/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 '{
  "searches": [
    "Skoda Octavia"
  ],
  "countries": [
    "DE"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

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