# AutoScout24 Scraper 🚗 (dealer phone included) (`tagadanar/autoscout24-scraper`) Actor

Scrape AutoScout24 car listings with a real filter search: make, model, price, year, mileage, fuel, dealer or private. Flat JSON with price, year, km, gearbox, power, seller type, dealer name and phone, city and photo. Covers the DE, AT, BE, ES, FR, IT and NL sites. No API key.

- **URL**: https://apify.com/tagadanar/autoscout24-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (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.70 / 1,000 listing scrapeds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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: Car Listings as JSON, Dealer Phone Included

Search AutoScout24 the way you would on the site and get the results as clean JSON. Set make, model, price range, year, mileage, fuel and seller type as plain input fields, no need to hand-craft AutoScout24 URLs. Every record carries the price, the key specs, the location and the seller's phone number when the site shows one, which for dealers is nearly always.

It covers seven AutoScout24 country sites: Germany, Austria, Belgium, Spain, France, Italy and the Netherlands. If you already have a search URL from your browser you can paste it as-is instead of using the filters.

### What you get per listing

| Field | Description |
| --- | --- |
| `title`, `make`, `model` | The car, as AutoScout24 names it |
| `price`, `currency` | Asking price in EUR |
| `year`, `firstRegistration` | First registration year and month (`06/2009`) |
| `mileage` | Odometer reading in km |
| `fuelType` | Fuel in plain English: petrol, diesel, electric, hybrid, lpg, cng, hydrogen |
| `gearbox`, `power` | Transmission and engine power, e.g. `75 kW (102 PS)` |
| `offerType` | new, used, demonstration or pre-registered |
| `sellerType` | dealer or private |
| `sellerPhone` | The seller's phone number when published (dealers nearly always, some private sellers too) |
| `dealerName`, `dealerRating`, `dealerRatingCount`, `dealerPageUrl` | Dealer company name, its AutoScout24 rating and dealer page |
| `city`, `zip`, `country` | Where the car is |
| `url`, `imageUrl`, `id` | Listing link, main photo and listing ID |
| `scrapedAt` | Run timestamp |

### Who uses it

- Dealers and car flippers sourcing inventory: filter by price band, year and mileage, export to a spreadsheet, call the seller.
- Lead generation teams: `dealerName` plus `sellerPhone` per record is a ready dealer contact list for any region and brand, at the price of a listings scrape.
- Market and pricing analysts tracking asking prices for a model across countries.
- Anyone shopping seriously for a car who wants the market in one table instead of forty browser tabs.

### Input examples

Diesel VW Golfs in Germany under 20,000 EUR, recent and low-mileage:

```json
{
  "make": "Volkswagen",
  "model": "Golf",
  "country": "de",
  "priceTo": 20000,
  "yearFrom": 2018,
  "mileageMax": 100000,
  "fuelType": "diesel",
  "maxResults": 500
}
````

Private-seller Clios in France (no dealers):

```json
{
  "make": "Renault",
  "model": "Clio",
  "country": "fr",
  "sellerType": "private",
  "maxResults": 200
}
```

Paste search URLs straight from your browser, filters included:

```json
{
  "searchUrls": [
    "https://www.autoscout24.de/lst/bmw/320?fregfrom=2019&kmto=80000&fuel=D",
    "https://www.autoscout24.it/lst/fiat/panda?priceto=8000"
  ],
  "maxResults": 1000
}
```

### How it works

The actor reads the same data AutoScout24's own result pages are built from, 100 listings per request, so runs are fast and records match what a visitor sees. Results are deduplicated by listing ID within a run.

One search window on AutoScout24 serves at most 4,000 results. When your query holds more than that and you asked for more, the actor automatically splits it into price bands and works through them, so a large pull does not silently stop at the window. If you use pasted URLs, keep each one under 4,000 results or split it yourself the same way.

### Pricing

You pay per listing delivered, platform usage included in the price. There is no proxy, no subscription and no compute line on your bill; the price per listing is the whole bill.

| Event | Price |
| --- | --- |
| Listing scraped | $1.00 per 1,000 |
| Actor start | $0.001 per run |

Listings you do not receive cost nothing: the cap stops the run, duplicates are filtered before charging, and the tiny start fee only exists so a run that returns zero results still covers its overhead.

### FAQ

**Do I need an API key or an account?** No. The actor reads AutoScout24's public result pages directly.

**Which countries are covered?** autoscout24.de, .at, .be, .es, .fr, .it and .nl. Pick one per run with `country`, or mix countries in one run via `searchUrls`.

**Are dealer phone numbers really included?** Yes. AutoScout24 publishes dealer phone numbers on its result pages and the record carries them in `sellerPhone`, with the company name in `dealerName`. Some private sellers publish a number too; when they do not, the field is `null`.

**Do private listings appear?** Yes. Both dealer and private listings are returned by default; set `sellerType` to narrow to one side.

**How do I spell the make and model?** As AutoScout24 does: "Mercedes-Benz", "Alfa Romeo", "Golf", "320". Accents do not matter, the actor converts names to the site's URL form. If the make is not one the site knows, the run stops with a clear message instead of returning unrelated cars.

**How many listings can one run return?** As many as your filters hold. Queries over 4,000 results are split into price bands automatically, so a whole-brand or whole-country pull works; it just takes more requests.

**Can I get new cars only, or exclude damaged ones?** Damaged listings are excluded by default. `offerType` in each record tells you whether the car is new, used, a demonstration car or pre-registered, so you can filter after the run.

**Does it slow down or get blocked on big pulls?** Runs pace themselves politely. In our measurements the result pages serve reliably without any proxy, which is why there is no proxy cost in the price.

***

### Something missing?

If you need an extra field or a filter you use on the site is not exposed here, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More marketplace and listings Actors are on [my profile](https://apify.com/tagadanar).

*AutoScout24 scraper, AutoScout24 API alternative, scrape AutoScout24, car listings scraper, used car data, used car prices Europe, car dealer leads, dealer phone numbers, auto market analysis, Gebrauchtwagen Daten, voiture occasion données.*

# Actor input Schema

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

Car make as AutoScout24 spells it, e.g. <code>Volkswagen</code>, <code>BMW</code>, <code>Mercedes-Benz</code>, <code>Alfa Romeo</code>. Leave empty to search across all makes.

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

Model name, e.g. <code>Golf</code>, <code>320</code>, <code>Clio</code>. Needs a make to work.

## `country` (type: `string`):

Which AutoScout24 country site to search.

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

Lowest price to include.

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

Highest price to include.

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

Earliest first-registration year, e.g. <code>2018</code>.

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

Latest first-registration year.

## `mileageMax` (type: `integer`):

Highest mileage to include, in kilometers.

## `fuelType` (type: `string`):

Restrict to one fuel type.

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

Dealers, private sellers, or both.

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

Stop after this many listings. You are only charged for listings actually delivered.

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

Paste one or more AutoScout24 result-page URLs straight from your browser, filters included. When set, the structured filters above are ignored.

## Actor input object example

```json
{
  "make": "Volkswagen",
  "model": "Golf",
  "country": "de",
  "fuelType": "any",
  "sellerType": "any",
  "maxResults": 20
}
```

# Actor output Schema

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

One item per car listing in the default dataset.

# 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 = {
    "make": "Volkswagen",
    "model": "Golf",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = {
    "make": "Volkswagen",
    "model": "Golf",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "make": "Volkswagen",
  "model": "Golf",
  "maxResults": 20
}' |
apify call tagadanar/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoScout24 Scraper 🚗 (dealer phone included)",
        "description": "Scrape AutoScout24 car listings with a real filter search: make, model, price, year, mileage, fuel, dealer or private. Flat JSON with price, year, km, gearbox, power, seller type, dealer name and phone, city and photo. Covers the DE, AT, BE, ES, FR, IT and NL sites. No API key.",
        "version": "0.1",
        "x-build-id": "cGeB1kibW9jTIWhm8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~autoscout24-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-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/tagadanar~autoscout24-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-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/tagadanar~autoscout24-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-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 make as AutoScout24 spells it, e.g. <code>Volkswagen</code>, <code>BMW</code>, <code>Mercedes-Benz</code>, <code>Alfa Romeo</code>. Leave empty to search across all makes."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Model name, e.g. <code>Golf</code>, <code>320</code>, <code>Clio</code>. Needs a make to work."
                    },
                    "country": {
                        "title": "Country site",
                        "enum": [
                            "de",
                            "at",
                            "be",
                            "es",
                            "fr",
                            "it",
                            "nl"
                        ],
                        "type": "string",
                        "description": "Which AutoScout24 country site to search.",
                        "default": "de"
                    },
                    "priceFrom": {
                        "title": "Price from (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest price to include."
                    },
                    "priceTo": {
                        "title": "Price up to (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest price to include."
                    },
                    "yearFrom": {
                        "title": "First registration from",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Earliest first-registration year, e.g. <code>2018</code>."
                    },
                    "yearTo": {
                        "title": "First registration up to",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Latest first-registration year."
                    },
                    "mileageMax": {
                        "title": "Mileage up to (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest mileage to include, in kilometers."
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "enum": [
                            "any",
                            "petrol",
                            "diesel",
                            "electric",
                            "hybrid",
                            "lpg",
                            "cng",
                            "hydrogen"
                        ],
                        "type": "string",
                        "description": "Restrict to one fuel type.",
                        "default": "any"
                    },
                    "sellerType": {
                        "title": "Seller",
                        "enum": [
                            "any",
                            "dealer",
                            "private"
                        ],
                        "type": "string",
                        "description": "Dealers, private sellers, or both.",
                        "default": "any"
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many listings. You are only charged for listings actually delivered.",
                        "default": 100
                    },
                    "searchUrls": {
                        "title": "Search URLs (optional, replaces the filters above)",
                        "type": "array",
                        "description": "Paste one or more AutoScout24 result-page URLs straight from your browser, filters included. When set, the structured filters above are ignored.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```