# AutoScout24 Scraper (`scraptivo/autoscout24-scraper`) Actor

Scrape car listings from AutoScout24 with full filter support. Extract makes, models, prices, mileage, seller info, and more.

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

## Pricing

from $1.00 / 1,000 cars

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**AutoScout24 Scraper** collects car listings from [AutoScout24](https://www.autoscout24.de) — Europe's largest automotive marketplace — and turns them into structured data for market research, price monitoring, and lead generation. Provide search queries or full search URLs, run the Actor, and export makes, models, prices, mileage, seller details, and images across 19 European countries to JSON, CSV, Excel, or your preferred integration. Use it to analyze the used-car market, track competitor inventory, and collect dealer contacts. Pricing starts at **$1 per 1,000 listings**.

### What can you automate with AutoScout24 Scraper?

- **Build car databases** — Collect detailed vehicle specs, pricing, and seller information across 19 European countries.
- **Monitor market trends** — Track listing prices, mileage patterns, and availability over time.
- **Analyze competitor inventory** — See what dealers are offering, at what prices, and how stock turns over.
- **Generate sales leads** — Extract seller company names, ratings, and listing URLs from thousands of listings.
- **Schedule recurring collection** — Run daily or weekly on the Apify Scheduler to keep market data current.
- **Feed data pipelines** — Push structured listing data through the Apify API or a webhook into dashboards and databases.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Automotive market researchers | Analyzing supply, demand, and pricing trends across the European used-car market. |
| Dealers and sales teams | Benchmarking competitor listings and pricing by make, model, and region. |
| Lead-generation teams | Collecting dealer contact details and seller ratings at scale. |
| Data analysts | Building normalized vehicle datasets for BI tools and custom applications. |

### What data can you collect from AutoScout24?

| Data group | Example fields | How it helps |
|---|---|---|
| Vehicle identity | `listingId`, `url`, `make`, `model`, `modelId` | Identify and deduplicate records with the stable `listingId`. |
| Pricing | `priceFormatted`, `priceRaw`, `priceCurrency`, `vatLabel`, `isConditionalPrice` | Compare asking prices across listings and countries. |
| Specifications | `mileageInKm`, `firstRegistration`, `fuel`, `transmission`, `engineDisplacementInCCM`, `powerKw`, `powerHp` | Filter and compare vehicles by hardware and condition. |
| Location | `locationCity`, `locationZip`, `locationCountryCode`, `distanceToSearchLocationInKm` | Map listings geographically. |
| Seller | `sellerId`, `sellerType`, `sellerCompanyName`, `sellerContactName`, `sellerRating` | Understand who is selling and their reputation. |
| Media | `imageUrl`, `images`, `hasVideo` | Grab primary and gallery images for each listing. |

### How to use AutoScout24 Scraper

1. Open the [AutoScout24 Scraper](https://apify.com/scraptivo/autoscout24-scraper) on Apify.
2. Enter **Search Queries** such as "audi" or "bmw 3er", or paste full AutoScout24 search URLs.
3. Optionally set filters for price, mileage, year, fuel type, transmission, and location.
4. Set **Max Items** to limit the number of listings (0 = unlimited).
5. Run the Actor and export the dataset or connect it to your workflow.

```json
{
    "searchQueries": ["audi", "bmw 3er", "mercedes-benz"],
    "maxItems": 100,
    "cy": "D",
    "ustate": "N,U",
    "atype": "C",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Track used Audi prices in Germany each week

1. Schedule a run every Monday with `searchQueries` = `["audi"]`, `ustate` = `"U"`, and `cy` = `"D"`.
2. Export the dataset and keep `model`, `priceRaw`, `mileageInKm`, `firstRegistration`, and `locationCity`.
3. Compare this week's `priceRaw` against last week's to spot price drops by model.
4. Deduplicate user-side against the stable `listingId`.

### Automate and integrate your results

- **Schedules** — Listings and prices change daily. Run **daily** for close price monitoring or **weekly** for market research. Create separate scheduled tasks per search query or country so each keeps its own dataset.
- **Webhooks** — Enable a webhook on run completion to push fresh listings into a CRM, database, or Slack pipeline.
- **Exports and API** — Download results as JSON, CSV, or Excel from the Apify Console, or call the Actor from the API:

```shell
curl "https://api.apify.com/v2/acts/scraptivo/autoscout24-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["audi", "bmw"],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
  }'
```

- **Deduplication** — The Actor appends new results on every run and does not deduplicate across runs. Use the stable `listingId` when merging results.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---:|---|---|---|
| `searchUrls` | Array of URLs | No | — | Full AutoScout24 search URLs (take priority over `searchQueries`). |
| `searchQueries` | Array of strings | No | `[]` | Car makes/models as URL path segments, e.g. "audi", "bmw 3er". |
| `maxItems` | Integer | No | `0` | Maximum listings to scrape (`0` = unlimited). |
| `maxPages` | Integer | No | `0` | Maximum result pages per search (`0` = unlimited). |
| `sort` | Select | No | `standard` | Sort by standard, price, mileage, age, power, or first registration. |
| `ustate` | Select | No | `N,U` | Vehicle condition: new, used, or both. |
| `cy` | Select | No | `D` | Country code (Germany default; 19 countries supported). |
| `pricefrom` / `priceto` | Integer | No | — | Filter by price range in EUR. |
| `kmfrom` / `kmto` | Integer | No | — | Filter by mileage range in km. |
| `yearfrom` / `yearto` | Integer | No | — | Filter by first registration year range. |
| `proxyConfiguration` | Proxy object | No | Apify proxy, RESIDENTIAL | Proxy settings for the run. |

Additional filters cover fuel type, transmission, body type, color, power, seats, doors, emission class, and more. See the Input tab in Apify Console for the full list.

### Output example

Each dataset item is one vehicle listing:

```json
{
    "listingId": "d92fb2a9-72a8-4b4a-a647-fdba919e9804",
    "url": "https://www.autoscout24.de/angebote/audi-a3-sportback-35-tfsi-benzin-schwarz-d92fb2a9-72a8-4b4a-a647-fdba919e9804",
    "make": "Audi",
    "model": "A3",
    "modelId": 1624,
    "offerType": "U",
    "priceFormatted": "€ 18.480",
    "priceRaw": 18480,
    "priceCurrency": "EUR",
    "mileageInKm": "72.288 km",
    "fuel": "Benzin",
    "transmission": "Automatik",
    "engineDisplacementInCCM": "1.498 cm³",
    "locationCity": "Ursensollen",
    "locationZip": "92289",
    "locationCountryCode": "DE",
    "sellerType": "Dealer",
    "sellerCompanyName": "Fischer Automobile GmbH & Co. KG",
    "sellerRating": "4.5",
    "imageUrl": "https://prod.pictures.autoscout24.net/listing-images/...",
    "images": ["..."],
    "availableNow": true
}
```

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

The Actor uses pay-per-event pricing. Each listing record pushed to the dataset counts as one `cars` event, billed at **$0.001 per listing** — that is **$1 per 1,000 listings**. A one-time actor-start event is also charged per run (one event per GB of memory, minimum one). Compute units consumed are deducted from your Apify plan, and volume discounts on paid Apify plans reduce the per-1,000 rate. When your event spending limit is reached, the run stops gracefully.

### Reliability and responsible use

- **Proxy requirement** — The Actor defaults to the Apify proxy with the RESIDENTIAL group. Residential IPs are recommended for consistent access to AutoScout24.
- **Retries and rate limits** — The Actor includes built-in retry logic and handles rate limiting gracefully.
- **Conditional fields** — `sellerContactName` and `firstRegistration` are populated when the platform provides them; some fields are nullable.
- **Public data** — The Actor collects publicly visible listing information from AutoScout24.
- **Responsible use** — Only use the data in ways that comply with AutoScout24's terms of service and applicable law.

### Frequently asked questions

#### Can I scrape AutoScout24 by make and model?

Yes. Enter makes or models as search queries — for example "audi", "bmw 3er", or "mercedes-benz" — and the Actor returns all matching listings. You can also paste full search URLs.

#### Can I filter by price, mileage, and location?

Yes. Set `pricefrom`/`priceto`, `kmfrom`/`kmto`, `yearfrom`/`yearto`, `zip`, `zipr`, `city`, and `cy` to narrow results. Additional filters cover fuel type, transmission, body type, and more.

#### Can I schedule the AutoScout24 Scraper to run automatically?

Yes. Open the **Scheduler** tab in Apify Console and set a recurring schedule. Daily suits close price monitoring; weekly suits market research. Create separate scheduled tasks per search query or country.

#### What counts as one result?

A listing record pushed to the dataset counts as one `cars` result ($1 per 1,000 listings). A small one-time actor-start event is also charged at the start of each run.

#### Why are some fields empty?

Fields such as `sellerContactName`, `firstRegistration`, and `vatLabel` are populated only when the platform exposes them. A null value usually means AutoScout24 has no data for that field.

#### How do I avoid duplicate records?

The Actor appends results on every run and does not deduplicate across runs. Use the stable `listingId` as the key when merging a fresh run into existing data.

#### Do I need a proxy?

The Actor works out of the box with the default Apify residential proxy, which is recommended for reliable access to AutoScout24.

### Related Scraptivo automations

- **[Cars.com Scraper](https://apify.com/scraptivo/cars-scraper)** — Scrape US car listings from Cars.com by search URL.
- **[Kleinanzeigen Scraper](https://apify.com/scraptivo/kleinanzeigen-scraper)** — Collect classifieds listings from Kleinanzeigen for market research.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

Full AutoScout24 search URLs (e.g. https://www.autoscout24.de/lst/audi?city=Berlin\&priceto=40000). When provided, these take priority over searchQueries.

## `searchQueries` (type: `array`):

Car makes or models to search for. Enter as autoscout24 URL path segments. Examples: 'audi', 'bmw', 'volkswagen', 'bmw 1er' (BMW 1 Series), 'audi a4' (Audi A4), 'mercedes-benz' (Mercedes-Benz). Use hyphens for multi-word brands and / (space) for brand/model separation.

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

Maximum number of listings to scrape (0 = unlimited)

## `maxPages` (type: `integer`):

Maximum number of result pages to scrape per search (0 = unlimited)

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

How to sort the results

## `desc` (type: `boolean`):

Sort in descending order

## `ustate` (type: `string`):

New, used, or both

## `atype` (type: `string`):

Vehicle category

## `pricefrom` (type: `integer`):

Filter by minimum price in EUR

## `priceto` (type: `integer`):

Filter by maximum price in EUR

## `kmfrom` (type: `integer`):

Filter by minimum mileage in kilometers

## `kmto` (type: `integer`):

Filter by maximum mileage in kilometers

## `yearfrom` (type: `integer`):

Filter by minimum first registration year

## `yearto` (type: `integer`):

Filter by maximum first registration year

## `powerfrom` (type: `integer`):

Filter by minimum engine power (unit depends on powertype setting)

## `powerto` (type: `integer`):

Filter by maximum engine power (unit depends on powertype setting)

## `powertype` (type: `string`):

Unit for power filter values

## `seatsfrom` (type: `integer`):

Filter by minimum number of seats

## `seatsto` (type: `integer`):

Filter by maximum number of seats

## `doorsfrom` (type: `integer`):

Filter by minimum number of doors

## `doorsto` (type: `integer`):

Filter by maximum number of doors

## `gear` (type: `string`):

Filter by transmission type (comma-separated codes)

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

Filter by fuel type (comma-separated codes)

## `body` (type: `string`):

Filter by body type (comma-separated codes)

## `color` (type: `string`):

Filter by exterior color (comma-separated codes)

## `zip` (type: `string`):

Filter by location (ZIP code or city name, e.g. 'Berlin' or '10115')

## `zipr` (type: `integer`):

Search radius around the ZIP/city in kilometers

## `city` (type: `string`):

City name for location-based search

## `cy` (type: `string`):

Filter by country code

## `custtype` (type: `string`):

Filter by seller type

## `ocs_listing` (type: `string`):

Include/exclude online car sale listings

## `damaged_listing` (type: `string`):

Include or exclude damaged/repaired vehicles

## `pricetype` (type: `string`):

Price visibility type

## `emissionclass` (type: `string`):

Filter by emission class (comma-separated codes)

## `emissionsticker` (type: `string`):

Filter by German emission sticker (Umweltplakette)

## `climatisation` (type: `string`):

Filter by air conditioning type (comma-separated codes)

## `interior` (type: `string`):

Filter by interior material type (comma-separated codes)

## `consumptionfrom` (type: `number`):

Filter by minimum fuel consumption

## `consumptionto` (type: `number`):

Filter by maximum fuel consumption

## `co2from` (type: `integer`):

Filter by minimum CO2 emissions

## `co2to` (type: `integer`):

Filter by maximum CO2 emissions

## `weightfrom` (type: `integer`):

Filter by minimum weight in kilograms

## `weightto` (type: `integer`):

Filter by maximum weight in kilograms

## `cylindersfrom` (type: `integer`):

Filter by minimum number of cylinders

## `cylindersto` (type: `integer`):

Filter by maximum number of cylinders

## `cubiccapacityfrom` (type: `integer`):

Filter by minimum engine displacement in ccm

## `cubiccapacityto` (type: `integer`):

Filter by maximum engine displacement in ccm

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

Proxy settings for anti-bot protection

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://www.autoscout24.de/lst/audi"
    }
  ],
  "searchQueries": [
    "audi",
    "bmw 3er"
  ],
  "maxItems": 0,
  "maxPages": 0,
  "sort": "standard",
  "desc": false,
  "ustate": "N,U",
  "atype": "C",
  "powertype": "kw",
  "gear": "",
  "fuel": "",
  "body": "",
  "color": "",
  "zipr": 0,
  "cy": "D",
  "custtype": "",
  "ocs_listing": "include",
  "damaged_listing": "exclude",
  "pricetype": "public",
  "emissionclass": "",
  "emissionsticker": "",
  "climatisation": "",
  "interior": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Dataset containing scraped car listings

# 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": [
        {
            "url": "https://www.autoscout24.de/lst/audi"
        }
    ],
    "searchQueries": [
        "audi",
        "bmw 3er"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraptivo/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": [{ "url": "https://www.autoscout24.de/lst/audi" }],
    "searchQueries": [
        "audi",
        "bmw 3er",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/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 '{
  "searchUrls": [
    {
      "url": "https://www.autoscout24.de/lst/audi"
    }
  ],
  "searchQueries": [
    "audi",
    "bmw 3er"
  ]
}' |
apify call scraptivo/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

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