# AutoScout24 Germany Car Listings Scraper (`automation-lab/autoscout-europe-listings`) Actor

Export public AutoScout24 car listings in Germany from filtered search URLs, with prices, vehicle specifications, images and listing provenance.

- **URL**: https://apify.com/automation-lab/autoscout-europe-listings.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.48 / 1,000 car 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 Germany Car Listings Scraper

Export public **autoscout24 car listings** in Germany from filtered search URLs. Get normalized asking prices, vehicle specifications, a listing image URL and source provenance for spreadsheet analysis or recurring inventory snapshots.

This Actor collects the advertised search-result information, not full vehicle detail pages or private contacts. It is independent of, and not affiliated with or endorsed by, AutoScout24.

### Who is it for?

- Vehicle buyers comparing advertised prices within a defined German search.
- Analysts building used-car price and mileage samples.
- Dealers refreshing a public inventory comparison spreadsheet.
- Data teams collecting repeatable snapshots for their own downstream comparisons.

### Why use it?

Paste an existing filtered Germany car search rather than rebuilding filters in another interface. Every record retains the search page, public listing URL and extraction timestamp. Stable listing IDs make downstream deduplication and comparison straightforward.

The extraction is HTTP-only: it does not download photos or launch a browser. Seller names, phone numbers, emails, contact people and street addresses are intentionally not included.

### Getting started

1. Open an AutoScout24.com car search and choose Germany.
2. Copy its HTTPS `/lst` URL and check that it contains `cy=D`.
3. Add it to `startUrls` below.
4. Choose a global listing limit and a per-search page limit.
5. Run the Actor and inspect the default dataset.
6. Export through Apify in JSON, CSV, Excel or another supported dataset format.

```json
{
  "startUrls": [{"url": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"}],
  "maxItems": 25,
  "maxPages": 2
}
```

### Input parameters

| Input | Default | Meaning |
| --- | --- | --- |
| `startUrls` | Required | 1–10 HTTPS AutoScout24.com `/lst` search URLs, each explicitly containing `cy=D`. `atype=C` is added when omitted. |
| `maxItems` | 100 | Global limit of 1–5000 unique eligible records across all URLs, after exclusions and deduplication. |
| `maxPages` | 5 | Up to 1–200 pages per supplied URL, beginning at its `page` value or page 1. |

Other countries, duplicate country parameters, non-car article types, listing detail URLs, credentials in URLs and unrelated hosts are rejected. Unknown input fields are rejected instead of silently ignored. Neither numeric limit accepts zero or unlimited. URL entries accept only `url` and optional `method: "GET"`; custom headers, payload and userData are rejected.

Search query parameters such as make, model, price and fuel are passed unchanged to AutoScout24. Their matching semantics are the source's, not a local text matcher. Changing site filters can change the returned sample. Only main car results with a verified `DE` location are exported; recommended and online-checkout results are excluded.

### Extracted fields

| Field | Description |
| --- | --- |
| `listingId` | Stable AutoScout24 listing identifier |
| `url`, `title` | Public listing URL and advertised heading |
| `brand`, `model` | Structured make and model |
| `price` | Numeric advertised asking price, not a valuation or sale price |
| `currency` | `EUR` when the displayed amount explicitly uses the euro symbol; otherwise null |
| `mileageKm` | Numeric odometer distance in kilometers, when available |
| `fuel`, `transmission` | Source labels |
| `firstRegistration` | Source month/year label, such as `09-2009`, not an ISO date |
| `imageUrl` | First advertised image URL; the image is not downloaded |
| `country`, `city` | Verified `DE` location and advertised city |
| `sourceUrl`, `scrapedAt` | Actual search page and UTC extraction timestamp |

Missing optional information is null. The default dataset contains only listing records, without diagnostic placeholder rows.

### Output example

The following illustrates the normalized structure observed in the BMW search. IDs and URLs are anonymized.

```json
{
  "listingId": "example-listing-id",
  "url": "https://www.autoscout24.com/offers/example-listing",
  "title": "BMW 118",
  "brand": "BMW",
  "model": "118",
  "price": 2799,
  "currency": "EUR",
  "mileageKm": 266692,
  "fuel": "Diesel",
  "transmission": "Manual",
  "firstRegistration": "09-2009",
  "imageUrl": "https://prod.pictures.autoscout24.net/listing-images/example.jpg",
  "country": "DE",
  "city": "Isernhagen",
  "sourceUrl": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&page=1",
  "scrapedAt": "2026-10-17T00:00:00.000Z"
}
```

### How much does it cost to export AutoScout24 car listings?

Pay-per-event pricing consists of a one-time start event plus a listing event for each delivered dataset record. The start fee is **$0.0005 per run**. Listing prices depend on your Apify spend tier:

| Tier | Price per listing |
| --- | --- |
| FREE | $0.00092 |
| BRONZE | $0.0008 |
| SILVER | $0.000624 |
| GOLD, PLATINUM, DIAMOND | $0.00048 |

Example calculation (BRONZE, including one start fee): 5 × $0.0008 + $0.0005 = $0.0045 total; 25 × $0.0008 + $0.0005 = $0.0205 total; 100 × $0.0008 + $0.0005 = $0.0805 total. These are estimates before any applicable taxes or account adjustments; consult the pricing panel for your actual tier. No separate charge applies to image URLs, specifications or provenance fields.

Apify spend tiers depend on your qualifying aggregate monthly Store spending, not the number of rows in this Actor alone. Higher spend tiers do not increase the listing unit price. Billing limits can stop a run before the requested collection limit. Valid empty searches can incur the start fee but no listing events.

### Pagination and completeness

The Actor follows numbered search pages sequentially, preserving supplied filters. It deduplicates listing IDs across pages and URLs within a run. It does not retain a cross-run inventory or return only changed listings.

Collection stops at the earliest of `maxItems`, `maxPages`, source exhaustion, absolute source page 200, runtime or billing limits. The default timeout is 900 seconds; large searches take several minutes and may need appropriately configured run options. AutoScout24 can cap results, change ranking or remove listings during a run. A snapshot is not a complete inventory census, historical database or guarantee that an offer is still available.

### Failures and troubleshooting

Temporary network failures, HTTP 429 and server errors receive at most three total attempts with bounded backoff. Invalid input, redirects, challenges, missing structured search data and parser errors fail explicitly. There is no automatic paid proxy or browser fallback.

A verified zero-result search succeeds with an empty dataset. A challenge or empty shell does not masquerade as a valid empty search. If a later page fails, previously written rows remain partial output; do not interpret a failed run as complete.

- **Rejected country:** use a `.com/lst` URL containing `cy=D`, not Switzerland or an all-Europe search.
- **Fewer rows than requested:** inspect the per-search page limit, source count, exclusions and duplicate IDs.
- **Blocked upstream request:** retry later after reviewing the failed run; this Actor does not promise anti-bot bypass.
- **Unexpected source filters:** verify the same URL in AutoScout24 and confirm its visible search settings.

### Integrations

Download a CSV for spreadsheet comparisons, or route dataset records into Google Sheets, a database or a BI pipeline through Apify integrations. Use `listingId` as an upsert key and retain `scrapedAt` to compare separate scheduled snapshots.

Scheduling is provided by Apify. Price-change detection, alerts, deletion detection and historical storage require your own downstream workflow; they are not built into this Actor.

### API usage

Keep your Apify token secret. This synchronous endpoint is suitable for small bounded jobs; for longer jobs start an asynchronous run and follow that same run ID.

#### cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~autoscout-europe-listings/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.autoscout24.com/lst/bmw?cy=D&atype=C"}],"maxItems":25,"maxPages":2}'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/autoscout-europe-listings').call({
  startUrls: [{ url: 'https://www.autoscout24.com/lst/bmw?cy=D&atype=C' }],
  maxItems: 25, maxPages: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 25 });
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/autoscout-europe-listings').call(run_input={
    'startUrls': [{'url': 'https://www.autoscout24.com/lst/bmw?cy=D&atype=C'}],
    'maxItems': 25, 'maxPages': 2,
})
rows = client.dataset(run['defaultDatasetId']).list_items(limit=25).items
```

### MCP integration

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/autoscout-europe-listings"
```

For Claude Desktop, Cursor and VS Code, adapt this MCP JSON block to the client's configuration and authenticate with your Apify account:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/autoscout-europe-listings"
    }
  }
}
```

Example prompt: “Use the Germany car listings scraper with this AutoScout24 search URL; collect at most 25 records from two pages and summarize advertised prices and mileage.”

Discover actual tool names and schemas using scoped `tools/list`. Actor selection also exposes run/data helper tools, not exactly one tool. Start an authorized invocation once and retain its run ID and dataset ID. `call-actor` can return before completion (wait is at most 45 seconds). Follow the same run with `get-actor-run`, using bounded 2/4/8-second backoff capped at 10 seconds and a 120-second consumer deadline. On timeout report pending with the known run ID; never restart merely to poll.

After success, read bounded results using `get-dataset-items`: e.g. pages of 20 source rows, at most 100 rows and 64 KiB serialized UTF-8 content admitted to model context. Enforce byte limits host-side; disclose omitted/oversized data and continuation offsets. If the client cannot intercept large responses, do not promise a hard byte limit. Full exports belong in storage outside model context. Terminal failures mean any rows are partial. No universal context/token savings are promised.

### Legality and data handling

The Actor does not use AI at runtime. It fetches public search pages, keeps only the listed output fields and does not collect private contact data. AutoScout24 receives the search request; Apify hosts execution, storage and logs. You are responsible for lawful use, source terms and any downstream personal-data obligations. Public visibility is not permission for unrestricted reuse.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed, and reports are retained for 30 days. No raw source pages, seller contacts or cookies are intentionally stored in dataset results or diagnostics.

Dataset/input/log retention follows your Apify account's storage policy. This Actor does not set a custom storage expiry or retain an actor-global cache. Delete run storage through Apify controls when no longer needed; downstream copies require their own deletion policy. No separate paid supplier account, AI provider or proxy credential is required.

### FAQ

**Does it cover Switzerland or all Europe?** No. Only public Germany car results from AutoScout24.com search URLs are supported, despite the internal slug containing “europe”.

**Can I extract dealer emails or phone numbers?** No. Contact fields and private data are excluded.

**Are detail pages, vehicle history or sold prices available?** No. This is advertised search-result data, not a detail enrichment or valuation service.

**Can I monitor prices?** Schedule repeat runs and compare records externally by `listingId`. Built-in delta alerts or persistent history are not provided.

### Related workflows and support

This is a standalone Germany search-listing export. No related Actor is required. Use Apify dataset exports and integrations for downstream processing. For a problem, open an issue on this Actor's Apify page and include the run link and a non-sensitive description; never post credentials or private customer data.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/autoscout-europe-listings/changelog.md

# Actor input Schema

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

1–10 HTTPS autoscout24.com/lst search URLs. Each must explicitly contain cy=D; atype must be C or omitted. URL entries accept url and optional method=GET only; custom headers, payload and userData are rejected. Other query filters are passed to AutoScout24 unchanged; their semantics are determined by the source. Detail URLs and other domains are rejected. Pagination begins at the supplied page (default 1). Duplicate listing IDs across URLs are emitted once per run.

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

Global maximum unique eligible listings across all URLs after Germany/car/main-result filtering and deduplication. Default 100; 1–5000. Zero/unlimited is not supported. maxPages, the source page cap, runtime and billing limits can stop collection earlier.

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

Maximum pages requested for each supplied URL, starting at its page parameter or 1. Default 5; 1–200. Stops at source exhaustion or absolute page 200; maxItems is global. No unlimited option. Search ranking may change during collection.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
    }
  ],
  "maxItems": 20,
  "maxPages": 2
}
```

# Actor output Schema

## `dataset` (type: `string`):

Download records in JSON; use dataset export controls for CSV, Excel and other formats.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
        }
    ],
    "maxItems": 20,
    "maxPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/autoscout-europe-listings").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 = {
    "startUrls": [{ "url": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0" }],
    "maxItems": 20,
    "maxPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/autoscout-europe-listings").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 '{
  "startUrls": [
    {
      "url": "https://www.autoscout24.com/lst/bmw?atype=C&cy=D&sort=standard&desc=0"
    }
  ],
  "maxItems": 20,
  "maxPages": 2
}' |
apify call automation-lab/autoscout-europe-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/autoscout-europe-listings"
        }
    }
}
```

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/Z6iZdj5grLz00c7Sb/builds/aJgdjvmMsrJOl53Ec/openapi.json