# AutoScout24 Scraper (`automation-lab/autoscout24-scraper`) Actor

Scrape AutoScout24 car listings across Europe — prices, mileage, fuel type, transmission, dealer info, and images. Filter by make, model, country, price range, and year. No coding needed.

- **URL**: https://apify.com/automation-lab/autoscout24-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Extract car listings from [AutoScout24](https://www.autoscout24.com) — Europe's largest used and new car marketplace with over 764,000 listings across 9 countries. Get prices, mileage, dealer contacts, images, and full vehicle specs in minutes, without any coding.

> **Pay-per-result pricing** — only pay for listings you actually extract. First 20 results free with any Apify plan.

### 🔍 What does it do?

This actor scrapes AutoScout24's search pages and extracts structured data from every car listing. It reads data directly from the embedded **`__NEXT_DATA__` JSON** on each search page — meaning it's fast, accurate, and doesn't require a browser or JavaScript rendering.

For every car listing, it captures:

| Field | Description | Example |
|-------|-------------|---------|
| `make` | Car manufacturer | BMW, Audi, Volkswagen |
| `model` | Car model | X3, A4, Golf |
| `variant` | Full variant/trim name | 3.0d xDrive M Sport |
| `year` | First registration year | 2021 |
| `firstRegistration` | Month/year | 03/2021 |
| `priceEur` | Price in EUR (numeric) | 28500 |
| `priceFormatted` | Price as displayed | € 28,500 |
| `mileageKm` | Mileage in km (numeric) | 45000 |
| `fuelType` | Fuel type | Diesel, Gasoline, Electric |
| `transmission` | Gearbox type | Automatic, Manual |
| `powerKw` | Engine power | 140 kW (190 hp) |
| `engineCC` | Engine displacement | 1,998 cc |
| `offerType` | New or used | Used, New |
| `city` | Seller city | Munich |
| `zip` | Postal code | 80331 |
| `street` | Street address | Leopoldstr. 1 |
| `country` | Country code | DE |
| `sellerType` | Dealer or private seller | Dealer |
| `dealerName` | Dealer or contact name | BMW Niederlassung München |
| `dealerPhone` | Primary phone number | +49 (0)89 - 1234567 |
| `dealerPhones` | All phone numbers (array) | ["+49...", "+49..."] |
| `images` | Car photo URLs (array) | ["https://prod.pictures..."] |
| `url` | Full listing URL | https://www.autoscout24.com/offers/... |
| `scrapedAt` | Timestamp of extraction | 2026-04-01T02:57:22Z |

### 👤 Who is it for?

🚗 **Car dealerships and fleet managers** — monitor competitor pricing and benchmark your inventory against the broader market across Germany, France, Italy, and beyond.

📊 **Automotive analysts and researchers** — build pricing models, track market trends, or analyze EV adoption across European markets.

🤖 **Data engineers and developers** — feed AutoScout24 data into internal dashboards, pricing APIs, or valuation tools without scraping complexity.

💰 **Used car buyers and importers** — monitor deals in specific makes/models/countries and get notified when prices drop.

📣 **Marketing and lead generation agencies** — extract dealer contact data (name, phone, address) for B2B outreach campaigns.

### ✅ Why use this scraper?

- **First PPE scraper for AutoScout24** — all 6 competitors are free but unreliable. This actor charges only per result, making it cost-predictable.
- **Fast and lightweight** — pure HTTP + JSON extraction, no browser needed. 150 listings in under 30 seconds.
- **High-resolution images** — images are extracted at 800×600px (vs thumbnail-only in some competitors).
- **Pan-European coverage** — supports all 9 AutoScout24 countries: Germany, Austria, Belgium, France, Italy, Spain, Netherlands, Luxembourg.
- **Structured filters** — filter by make, model, country, price range, year range, and fuel type via the UI. No URL-building required.
- **Export-ready** — download results as JSON, CSV, XML, or Excel from Apify's dataset panel.

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

Pricing uses the **Pay-Per-Event** model — you pay per listing extracted, not per minute of compute.

| Volume | Cost |
|--------|------|
| First 20 listings | Free (any plan) |
| 100 listings | ~$0.31 (start $0.01 + 100 × $0.003) |
| 500 listings | ~$1.51 |
| 1,000 listings | ~$3.01 |
| 5,000 listings | ~$15.01 |

**Apify plan discounts** (per-listing fee at higher tiers):

| Plan | Per-listing price | Discount |
|------|-----------------|----------|
| FREE | $0.0030 | — |
| BRONZE | $0.0027 | 10% off |
| SILVER | $0.0024 | 20% off |
| GOLD | $0.00195 | 35% off |
| PLATINUM | $0.0015 | 50% off |
| DIAMOND | $0.0012 | 60% off |

> 💡 **Tip**: Run the default prefilled input (BMW, Germany, 20 results) to see how the actor works at zero cost.

### 🚀 How to scrape AutoScout24 — step by step

1. **Go to [AutoScout24 Scraper](https://apify.com/automation-lab/autoscout24-scraper)** on Apify Store.
2. Click **Try for free** — you get a free Apify account with $5 in monthly credits.
3. In the input form, set your filters:
   - **Make** — e.g. `bmw`, `audi`, `mercedes-benz`
   - **Country** — select Germany, France, Italy, etc.
   - **Max listings** — how many results you want
4. Click **Save & Run**.
5. Wait 5–30 seconds (depending on volume).
6. Download results as **JSON, CSV, or Excel** from the Dataset tab.

**Alternative**: Paste any AutoScout24 search URL directly in the "Search URLs" field — the scraper will follow your exact filter/sort settings.

### ⚙️ Input parameters

| Parameter | Type | Description | Default |
|-----------|------|-------------|---------|
| `startUrls` | Array | AutoScout24 search page URLs to scrape | — |
| `make` | String | Car make slug (e.g. `bmw`, `volkswagen`) | — |
| `model` | String | Model slug (e.g. `3er`, `golf`) | — |
| `country` | Select | Country to search: `D`=Germany, `F`=France, `I`=Italy, etc. | `D` |
| `priceFrom` | Integer | Minimum price in EUR | — |
| `priceTo` | Integer | Maximum price in EUR | — |
| `yearFrom` | Integer | Earliest first registration year | — |
| `yearTo` | Integer | Latest first registration year | — |
| `fuelType` | Select | Fuel type: `B`=Gasoline, `D`=Diesel, `E`=Electric, etc. | — |
| `maxListings` | Integer | Maximum listings to extract (1–8000) | 100 |

#### Using startUrls

If you need advanced filters (color, transmission, body type, seller type), configure your search on AutoScout24's website, then copy the URL into the `startUrls` field:

```json
{
  "startUrls": [
    { "url": "https://www.autoscout24.com/lst/bmw/3er?cy=D&fregfrom=2020&fuel=D&sort=price&desc=0&size=20" }
  ],
  "maxListings": 200
}
````

### 📦 Output example

Each extracted car listing looks like this:

```json
{
  "id": "d1e33be2-73ae-4812-8fb3-664746842765",
  "url": "https://www.autoscout24.com/offers/bmw-x3-diesel-grey-d1e33be2...",
  "make": "BMW",
  "model": "X3",
  "variant": "X3",
  "offerType": "Used",
  "year": 2021,
  "firstRegistration": "03/2021",
  "transmission": "Automatic",
  "fuelType": "Diesel",
  "mileageKm": 45000,
  "engineCC": "1,995 cc",
  "powerKw": "140 kW (190 hp)",
  "priceEur": 28500,
  "priceFormatted": "€ 28,500",
  "city": "Munich",
  "zip": "80331",
  "street": "Leopoldstr. 1",
  "country": "DE",
  "sellerType": "Dealer",
  "dealerName": "BMW Niederlassung München",
  "dealerPhone": "+49 (0)89 - 1234567",
  "dealerPhones": ["+49 (0)89 - 1234567"],
  "images": [
    "https://prod.pictures.autoscout24.net/listing-images/d1e33be2.../800x600.jpg"
  ],
  "scrapedAt": "2026-04-01T02:57:22.306Z"
}
```

### 💡 Tips and tricks

- **Use `startUrls` for complex filters** — the website UI supports body type, color, seller type, and more. Configure your search there, copy the URL, paste it in.
- **Country codes**: `A`=Austria, `B`=Belgium, `D`=Germany, `E`=Spain, `F`=France, `I`=Italy, `L`=Luxembourg, `NL`=Netherlands. Leave blank for all Europe.
- **Make slugs** use lowercase with hyphens: `mercedes-benz`, `alfa-romeo`, `land-rover`.
- **Fuel type codes**: `B`=Gasoline, `D`=Diesel, `E`=Electric, `2`=Gasoline/Electric Hybrid, `3`=Diesel/Electric Hybrid, `L`=LPG, `C`=CNG.
- **Max 8000 listings per run** — AutoScout24 limits search results to 400 pages × 20 per page. For larger datasets, split by make, model, or price range.
- **Year range filter** applies to first registration year, not model year.
- **Images are high-resolution** (800×600px) — suitable for product cards, comparisons, and visual tools.
- **Private sellers** will have `dealerName` set to their contact name and `sellerType` = `"Private"`.

### 🌍 Supported countries and filters

AutoScout24 Scraper works with all 9 countries where AutoScout24 operates:

| Country code | Country | Example market |
|---|---|---|
| `D` | Germany | Largest market — BMW, Mercedes, VW |
| `A` | Austria | Strong used import market |
| `B` | Belgium | High-volume transit country |
| `F` | France | Renault, Peugeot, Citroën dominant |
| `I` | Italy | Fiat, Alfa Romeo, Lancia focus |
| `E` | Spain | SEAT and economy cars popular |
| `NL` | Netherlands | High EV adoption |
| `L` | Luxembourg | Cross-border buyers |
| *(blank)* | All Europe | Pan-European search |

**Supported fuel types:**

| Code | Fuel type |
|------|-----------|
| `B` | Gasoline |
| `D` | Diesel |
| `E` | Electric |
| `2` | Gasoline/Electric Hybrid |
| `3` | Diesel/Electric Hybrid |
| `L` | LPG |
| `C` | CNG |

**Popular make slugs:** `bmw`, `mercedes-benz`, `volkswagen`, `audi`, `ford`, `toyota`, `renault`, `peugeot`, `opel`, `seat`, `skoda`, `volvo`, `alfa-romeo`, `land-rover`, `porsche`.

For advanced filters (color, body type, transmission, seller type), use AutoScout24's website to build your search, then copy the URL into the `startUrls` field — all filter parameters in the URL are automatically respected.

### 🔗 Integrations

#### Automated pricing intelligence workflow

1. **Run daily** via Apify Schedule (cron `0 9 * * *`).
2. Input: your target makes/models in Germany.
3. Connect dataset to **Google Sheets** via Apify's Google Sheets integration.
4. Build a pivot table showing avg/min/max price by model and year.
5. Set a Slack or email notification when prices drop below a threshold.

#### CRM lead generation for dealers

1. Run with country filter `D` or `F`, `sellerType` private (via startUrls).
2. Export dealer names and phones to CSV.
3. Import into your CRM (HubSpot, Salesforce) using Zapier or Make.

#### EV market tracking

1. Schedule weekly runs with `fuelType: "E"` across multiple countries.
2. Feed results to a time-series database.
3. Chart EV listing volume and average prices over time.

#### Webhook notifications

Use Apify webhooks to trigger downstream automation when a run finishes:

```json
{
  "eventTypes": ["ACTOR.RUN.SUCCEEDED"],
  "requestUrl": "https://hooks.zapier.com/hooks/catch/YOUR_ID/",
  "payloadTemplate": "{\"datasetId\": {{resource.defaultDatasetId}}}"
}
```

### 🛠️ API usage

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/autoscout24-scraper').call({
  make: 'bmw',
  country: 'D',
  fuelType: 'D',
  yearFrom: 2020,
  maxListings: 100,
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/autoscout24-scraper").call(run_input={
    "make": "volkswagen",
    "country": "D",
    "fuelType": "B",
    "priceFrom": 5000,
    "priceTo": 20000,
    "maxListings": 100,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
for car in items:
    print(f"{car['make']} {car['model']} ({car['year']}) — €{car['priceEur']:,} — {car['city']}")
```

#### cURL

```bash
## Start a run
curl -X POST "https://api.apify.com/v2/acts/automation-lab~autoscout24-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "make": "audi",
    "country": "D",
    "maxListings": 50
  }'

## Get results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?format=json" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

### 🤖 Use with AI agents via MCP

AutoScout24 Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add apify --transport http https://mcp.apify.com?tools=automation-lab/autoscout24-scraper
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file (`claude_desktop_config.json`, `.cursor/mcp.json`, or VS Code `settings.json`):

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/autoscout24-scraper to scrape the 50 cheapest diesel BMWs in Germany and show me the ones under €20,000"
- "Get 100 electric car listings from AutoScout24 in France and summarize the price range by make"
- "Find Volkswagen Golf listings from 2020 or newer, under €15,000, in Germany and export as CSV"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### ⚖️ Legal and compliance

AutoScout24 makes listing data publicly accessible without login. This scraper only collects publicly visible information — the same data any visitor can see on the website.

**Key considerations:**

- ✅ Only public data is extracted (no login, no private user data).
- ✅ Results are typically used for legitimate purposes: market research, price comparison, business intelligence.
- ⚠️ Do not use scraped data to re-publish or resell listings as-is — AutoScout24's terms prohibit this.
- ⚠️ Respect rate limits — use `maxListings` and schedule runs at reasonable intervals.
- ⚠️ GDPR applies to personal data (dealer names, phone numbers) — ensure you have a lawful basis if processing EU personal data.

Always review [AutoScout24's Terms of Service](https://www.autoscout24.com/info/usage-policies/terms-of-service) and [robots.txt](https://www.autoscout24.com/robots.txt) for the latest restrictions.

### ❓ FAQ

**Q: What countries does AutoScout24 cover?**

AutoScout24 operates in 9 European countries: Germany (DE), Austria (AT), Belgium (BE), France (FR), Italy (IT), Spain (ES), Netherlands (NL), Luxembourg (LU), and pan-European search. Use the `country` dropdown in the input or leave it blank for all Europe.

**Q: How many listings can I scrape?**

AutoScout24 paginates at up to 400 pages × 20 listings = 8,000 results per search query. For larger datasets, split your search by make, country, or price range and run multiple jobs.

**Q: Why is my run returning listings from the wrong make/country?**

The `make` field must match AutoScout24's slug exactly (e.g., `mercedes-benz` not `mercedes`, `alfa-romeo` not `alfaromeo`). If you're unsure of the slug, use `startUrls` with the URL copied directly from the website — that guarantees the exact filters you set on AutoScout24 are respected.

**Q: Can I scrape private seller listings?**

Yes — the scraper includes both dealer and private seller listings. `sellerType` will be `"Private"` for private sellers. Note that private sellers may not have a phone number in the listing (AutoScout24 hides it behind a contact form).

**Q: The run finished but I got fewer listings than requested — why?**

This happens when the search has fewer total results than your `maxListings` value. For example, if you search for a rare make/model combination in a small country, there may only be 50 listings available.

**Q: Images aren't loading — what happened?**

Image URLs are hosted by AutoScout24's CDN (`prod.pictures.autoscout24.net`). They are valid at the time of scraping. CDN links don't expire, but individual listings can be removed if the car is sold.

### 🔗 Related scrapers

Looking for more automotive or marketplace data?

- [**Facebook Marketplace Scraper**](https://apify.com/automation-lab/facebook-marketplace-scraper) — scrape Facebook Marketplace classifieds including cars, real estate, and items for sale.
- [**Kijiji Canada Scraper**](https://apify.com/automation-lab/kijiji-scraper) — extract Canadian classifieds from Kijiji including vehicles, real estate, and jobs.
- [**PropertyFinder.ae Scraper**](https://apify.com/automation-lab/propertyfinder-scraper) — scrape UAE property listings from PropertyFinder.ae.

Explore all our scrapers at [apify.com/automation-lab](https://apify.com/automation-lab).

# Actor input Schema

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

Paste any AutoScout24 search page URLs to scrape. Use the website's search/filter page and copy the URL. If provided, other search fields below are ignored.

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

Car manufacturer to search for (e.g. 'bmw', 'audi', 'volkswagen', 'mercedes-benz', 'toyota'). Use lowercase slug as it appears in AutoScout24 URLs.

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

Specific car model to filter by (e.g. '3er', 'a4', 'golf'). Use the model slug as it appears in AutoScout24 URLs. Leave empty to search all models of the selected make.

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

Country to search in. Select 'All Europe' for pan-European results.

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

Minimum listing price in EUR. Leave empty for no minimum.

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

Maximum listing price in EUR. Leave empty for no maximum.

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

Minimum first registration year (e.g. 2018). Leave empty for no minimum.

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

Maximum first registration year (e.g. 2024). Leave empty for no maximum.

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

Filter by fuel type. Leave empty for all fuel types.

## `maxListings` (type: `integer`):

Maximum number of car listings to scrape. Each listing costs ~$0.003. AutoScout24 shows up to 20 listings per page and max 400 pages.

## Actor input object example

```json
{
  "startUrls": [],
  "make": "bmw",
  "country": "D",
  "fuelType": "",
  "maxListings": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [],
    "make": "bmw",
    "model": "",
    "country": "D",
    "fuelType": "",
    "maxListings": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "startUrls": [],
    "make": "bmw",
    "model": "",
    "country": "D",
    "fuelType": "",
    "maxListings": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "startUrls": [],
  "make": "bmw",
  "model": "",
  "country": "D",
  "fuelType": "",
  "maxListings": 20
}' |
apify call automation-lab/autoscout24-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AutoScout24 Scraper",
        "description": "Scrape AutoScout24 car listings across Europe — prices, mileage, fuel type, transmission, dealer info, and images. Filter by make, model, country, price range, and year. No coding needed.",
        "version": "0.1",
        "x-build-id": "uYnvySt7ZWIWOfzPR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~autoscout24-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~autoscout24-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~autoscout24-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "startUrls": {
                        "title": "AutoScout24 search URLs",
                        "type": "array",
                        "description": "Paste any AutoScout24 search page URLs to scrape. Use the website's search/filter page and copy the URL. If provided, other search fields below are ignored.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "make": {
                        "title": "Car make",
                        "type": "string",
                        "description": "Car manufacturer to search for (e.g. 'bmw', 'audi', 'volkswagen', 'mercedes-benz', 'toyota'). Use lowercase slug as it appears in AutoScout24 URLs."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Specific car model to filter by (e.g. '3er', 'a4', 'golf'). Use the model slug as it appears in AutoScout24 URLs. Leave empty to search all models of the selected make."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "A",
                            "B",
                            "D",
                            "E",
                            "F",
                            "I",
                            "L",
                            "NL"
                        ],
                        "type": "string",
                        "description": "Country to search in. Select 'All Europe' for pan-European results.",
                        "default": "D"
                    },
                    "priceFrom": {
                        "title": "Min price (€)",
                        "type": "integer",
                        "description": "Minimum listing price in EUR. Leave empty for no minimum."
                    },
                    "priceTo": {
                        "title": "Max price (€)",
                        "type": "integer",
                        "description": "Maximum listing price in EUR. Leave empty for no maximum."
                    },
                    "yearFrom": {
                        "title": "Min year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Minimum first registration year (e.g. 2018). Leave empty for no minimum."
                    },
                    "yearTo": {
                        "title": "Max year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Maximum first registration year (e.g. 2024). Leave empty for no maximum."
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "enum": [
                            "",
                            "B",
                            "D",
                            "E",
                            "2",
                            "3",
                            "L",
                            "C",
                            "H",
                            "M",
                            "O"
                        ],
                        "type": "string",
                        "description": "Filter by fuel type. Leave empty for all fuel types.",
                        "default": ""
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 8000,
                        "type": "integer",
                        "description": "Maximum number of car listings to scrape. Each listing costs ~$0.003. AutoScout24 shows up to 20 listings per page and max 400 pages.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```