# Mobile.de Scraper (`scrapesmith/mobile-de-scraper`) Actor

Scrape mobile.de car listings with 90+ data points. Price, mileage, power, specs, full dealer contact with WhatsApp, images, equipment list. Search by make, model, price range, or paste URLs. JSON/CSV/Excel. API, MCP, webhook, AI-agent ready.

- **URL**: https://apify.com/scrapesmith/mobile-de-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 results

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## 🚗 Mobile.de Scraper

**Germany's largest car marketplace — structured vehicle data extracted in seconds, no code required.**

Extract clean, structured vehicle listing data from mobile.de in a ready-to-use dataset. Built for developers, data teams, dealers, and AI agents that need reliable German and European used-car data without writing a single line of scraping code.

### 🎯 Why use this scraper

✅ **No-code data extraction** — just enter search filters or paste mobile.de URLs, no browser extensions, no proxies to configure, no scraping expertise required.

✅ **Deep field coverage** — pulls listing details, full price breakdowns, vehicle specifications, seller/dealer contact info, location data, and complete photo galleries in a single run.

✅ **Built for scale** — works equally well for a single listing lookup or a bulk pull of thousands of vehicles across the entire German and Austrian markets.

✅ **Automation-ready** — plug straight into the Apify API, MCP server, webhooks, or your favorite no-code automation tool and start piping fresh car listing data into your stack today.

### 🚀 Features

✅ Search mobile.de by make, model, price range, mileage, first registration year, engine power, fuel type, transmission, body type, and exterior color

✅ Paste any mobile.de search-results URL or direct vehicle listing URL as an alternative to structured filters

✅ Location-based search using German ZIP code and radius

✅ Filter by seller type (dealer vs. private) and by damaged/accident-vehicle condition

✅ Optional deep detail pass for the full spec sheet, equipment list, and extended description on every listing

✅ Automatic result de-duplication across search filters and URLs

✅ Exhaustive mode to pull far beyond a single search's normal result ceiling on broad queries

✅ Full photo gallery URLs and video flag for every listing

✅ Complete seller/dealer contact card — name, address, phone, mobile, WhatsApp, geo-coordinates, rating, and opening hours

✅ Clean, structured JSON output ready for spreadsheets, databases, dashboards, or AI pipelines

### 📊 Output Fields

Every run returns one structured record per vehicle listing, organized into the following field groups.

#### Listing Details

| Field | Description |
|---|---|
| `id` | Unique mobile.de listing ID |
| `url` | Canonical URL of the listing |
| `title` | Full listing title |
| `shortTitle` | Short version of the title (make + model) |
| `subTitle` | Trim/variant subtitle |
| `description` | Full seller description text |
| `make` | Vehicle make/brand |
| `makeId` | Internal make ID |
| `model` | Vehicle model |
| `modelId` | Internal model ID |
| `category` | Listing category (car, motorcycle, van, etc.) |
| `segment` | Vehicle class/segment |

#### 💰 Price & Financing

| Field | Description |
|---|---|
| `price` | Listing price (numeric) |
| `priceCurrency` | Currency code (EUR) |
| `priceFormatted` | Localized, formatted price string |
| `priceType` | Price type (fixed, negotiable, etc.) |
| `priceRating` | Market price rating (e.g. good deal, fair, high) |
| `priceRatingLabel` | Human-readable price rating label |
| `priceRatingVehicleOffset` | Price offset vs. comparable market vehicles |

#### ⚙️ Vehicle Specs

| Field | Description |
|---|---|
| `condition` | Vehicle condition summary |
| `hasDamage` | Whether the listing is flagged as damaged/accident vehicle |
| `isNew` | Whether the vehicle is listed as new |
| `countryVersion` | Country/market version of the vehicle |
| `mileageKm` | Mileage in kilometers (numeric) |
| `mileageFormatted` | Raw formatted mileage string |
| `firstRegistration` | First registration date (MM/YYYY) |
| `firstRegistrationYear` | First registration year (numeric) |
| `cubicCapacityCc` | Engine displacement in cc |
| `powerKw` | Engine power in kilowatts |
| `powerHp` | Engine power in horsepower |
| `fuelType` | Fuel type |
| `transmission` | Transmission type |
| `numSeats` | Number of seats |
| `doorCount` | Door count |
| `cylinderCount` | Number of cylinders |
| `emissionClass` | Emission class (e.g. Euro 6) |
| `emissionsSticker` | German environmental badge/sticker |
| `co2EmissionsGkm` | CO₂ emissions (g/km) |
| `energyConsumption` | Energy consumption rating |
| `numberOfPreviousOwners` | Number of previous owners |
| `inspectionStatus` | Roadworthiness inspection (HU) status |
| `climatisation` | Air conditioning/climate control type |
| `parkingAssist` | Parking assist features |
| `airbags` | Airbag configuration |
| `colorManufacturer` | Manufacturer-specific color name |
| `color` | Exterior color |
| `interior` | Interior material/color |
| `netWeightKg` | Net weight in kilograms |
| `vinHsn` | German manufacturer registration key number (HSN) |
| `vinTsn` | German type registration key number (TSN) |
| `readyToDrive` | Whether the vehicle is ready to drive away |
| `hasElectricEngine` | Whether the vehicle has an electric drivetrain |
| `isDamageCase` | Damage-case flag |
| `isConditionNew` | New-condition flag |

#### 📸 Features & Media

| Field | Description |
|---|---|
| `features` | Full list of equipment/features |
| `highlights` | Highlighted selling points |
| `numImages` | Number of images in the gallery |
| `images` | Array of full-resolution image URLs |
| `isVideoEnabled` | Whether the listing has a video |
| `youtubeId` | Linked YouTube video ID, if present |

#### 👤 Seller / Dealer Info

| Field | Description |
|---|---|
| `sellerId` | Internal seller ID |
| `sellerType` | Dealer or private seller |
| `sellerName` | Seller/dealer name |
| `sellerCountry` | Seller country |
| `sellerAddress` | Seller street address |
| `sellerPhone` | Primary phone number |
| `sellerMobile` | Mobile phone number |
| `sellerFax` | Fax number |
| `sellerWhatsapp` | WhatsApp contact number |
| `sellerRatingScore` | Seller rating score |
| `sellerRatingCount` | Number of ratings |
| `sellerRatingTotalCount` | Total lifetime rating count |
| `sellerRatingUrl` | Link to seller rating page |
| `sellerRecommendationRate` | Recommendation rate percentage |
| `sellerHomepageUrl` | Seller/dealer homepage URL |
| `sellerLanguages` | Languages spoken by the seller |
| `sellerOpeningHours` | Dealer opening hours by day |
| `sellerWithMobileSince` | Date seller joined mobile.de |
| `partnerName` | Dealer partner/network name |

#### 📍 Location

| Field | Description |
|---|---|
| `sellerLatitude` | Seller/dealer latitude |
| `sellerLongitude` | Seller/dealer longitude |
| `country` | Listing marketplace/country |

#### ⏰ Metadata & Timestamps

| Field | Description |
|---|---|
| `makeKey` | Internal make key |
| `modelKey` | Internal model key |
| `version` | Listing version number |
| `createdAt` | Listing creation timestamp |
| `modifiedAt` | Last modified timestamp |
| `renewedAt` | Last renewal timestamp |
| `inputContext` | The search/filter context that produced this record |
| `scrapedAt` | Timestamp when the record was scraped |

### 💼 Use Cases

✅ **Market research** — track pricing trends, inventory volume, and model popularity across the German and Austrian used-car markets.

✅ **Price monitoring** — watch price movements on specific makes, models, or trims over time to spot deals or shifting demand.

✅ **Lead generation for dealers** — build prospect lists of private-seller listings or competing dealer inventory in a target region.

✅ **Competitor analysis** — benchmark a dealership's pricing, inventory mix, and stock turnover against competitors.

✅ **Data journalism** — power reporting on automotive market trends, EV adoption, or regional pricing disparities with real listing data.

✅ **Machine learning training data** — feed vehicle pricing and specification data into valuation models, recommendation engines, or forecasting tools.

✅ **Insurance and valuation tools** — enrich vehicle valuation and risk models with mileage, condition, registration, and specification data.

✅ **Marketplace aggregation** — combine mobile.de listings with other classifieds sources to build a unified vehicle search product.

### 📥 Input

Configure the scraper with structured search filters, direct URLs, or both:

```json
{
  "startUrls": [],
  "searchTerm": "",
  "make": "BMW",
  "priceMin": 10000,
  "priceMax": 40000,
  "mileageMax": 100000,
  "yearMin": 2018,
  "fuelType": ["PETROL", "DIESEL"],
  "transmission": ["AUTOMATIC_GEAR"],
  "sellerType": "Any",
  "country": "DE",
  "zipCode": "10115",
  "radiusKm": 100,
  "maxItems": 200,
  "includeFullDetails": true,
  "exhaustiveMode": false
}
````

**Key input options:**

✅ Search / listing URLs — paste any mobile.de search-results or vehicle-detail URL directly

✅ Search term — free-text keyword search for models, trims, or specific terms

✅ Make, price, mileage, year, power range — standard filter fields to narrow results

✅ Fuel type, transmission, body type, exterior color — multi-select filters

✅ ZIP code + radius — location-based search around a German postal code

✅ Seller type — dealers only, private sellers only, or both

✅ Max results — total cap on the number of listings returned

✅ Fetch full listing details — toggle the deeper per-listing enrichment pass

✅ Exhaustive mode — automatically segment very broad searches to retrieve more results than a single search normally exposes

*No API keys, logins, or cookies required — just set your filters and run.*

### 📤 Output Example

```json
{
  "id": "412738560",
  "url": "https://suchen.mobile.de/fahrzeuge/details.html?id=412738560",
  "title": "Audi A4 Avant 40 TDI S line quattro S tronic",
  "shortTitle": "Audi A4 Avant",
  "subTitle": "40 TDI S line quattro S tronic",
  "description": "Scheckheftgepflegt, Nichtraucherfahrzeug, Navi, LED-Scheinwerfer, Standheizung...",
  "make": "Audi",
  "model": "A4",
  "category": "Car",
  "segment": "Estate Car",
  "price": 32900,
  "priceCurrency": "EUR",
  "priceFormatted": "32.900 EUR",
  "priceType": "FIXED",
  "priceRating": "GOOD",
  "priceRatingLabel": "Good Price",
  "mileageKm": 68500,
  "mileageFormatted": "68.500 km",
  "firstRegistration": "03/2020",
  "firstRegistrationYear": 2020,
  "cubicCapacityCc": 1968,
  "powerKw": 140,
  "powerHp": 190,
  "fuelType": "Diesel",
  "transmission": "Automatic",
  "numSeats": 5,
  "doorCount": "5",
  "emissionClass": "Euro 6",
  "co2EmissionsGkm": 124,
  "numberOfPreviousOwners": 1,
  "color": "Grey",
  "interior": "Leather, Black",
  "vinHsn": "0588",
  "vinTsn": "BNS",
  "features": ["Navigation system", "LED headlights", "Parking sensors", "Heated seats"],
  "numImages": 24,
  "images": [
    "https://img.classistatic.de/api/v1/mo-prod/images/example1.jpg",
    "https://img.classistatic.de/api/v1/mo-prod/images/example2.jpg"
  ],
  "sellerId": "48213570",
  "sellerType": "Dealer",
  "sellerName": "Autohaus Meyer GmbH",
  "sellerCountry": "Germany",
  "sellerAddress": "Hauptstraße 22",
  "sellerPhone": "+49 (0)89 123456",
  "sellerWhatsapp": "+49 (0)151 12345678",
  "sellerLatitude": 48.1374,
  "sellerLongitude": 11.5755,
  "sellerRatingScore": 4.7,
  "sellerRatingCount": 312,
  "country": "GERMANY",
  "createdAt": "2026-06-02T09:14:00.000Z",
  "modifiedAt": "2026-07-10T15:42:00.000Z",
  "scrapedAt": "2026-07-20T08:00:00.000Z"
}
```

### 📁 Export Formats

Every run's results are available directly from your Apify dataset in the format you need:

✅ **JSON** — for direct API consumption, AI agents, and custom pipelines

✅ **CSV** — for spreadsheets, BI tools, and quick analysis

✅ **Excel (XLSX)** — for reporting and sharing with non-technical teams

✅ **XML** — for legacy systems and structured data exchange

### 🔗 Integrations

This scraper is built to slot straight into your existing stack:

🔗 **Apify API** — trigger runs and pull results programmatically from any language or platform

🔗 **Apify MCP server** — connect this scraper as a tool for AI agents, letting Claude, ChatGPT, and other LLMs query live vehicle listing data on demand

🔗 **Webhooks** — get notified automatically when a run finishes or new data is ready

🔗 **Zapier** — connect mobile.de listing data to thousands of other apps with no code

🔗 **Make (formerly Integromat)** — build automated workflows around fresh vehicle data

🔗 **n8n** — self-hosted workflow automation with native Apify support

🔗 **Google Sheets** — pipe results straight into a spreadsheet for easy sharing and analysis

🔗 **AI agents & LLM frameworks** — works out of the box with LangChain, Claude, ChatGPT, and other agent frameworks that consume structured JSON or MCP tools

### 💡 Tips for Best Results

💡 Use structured filters (make, price, mileage, year) for the most predictable, repeatable searches instead of relying only on free-text search terms.

💡 Turn on **Fetch full listing details** if you need the complete equipment list, extended description, or HSN/TSN registration codes — leave it off for faster, lighter runs when you only need the core listing and price fields.

💡 Combine **ZIP code + radius** with your other filters to focus on a specific regional market instead of scraping all of Germany.

💡 Enable **Exhaustive mode** only for very broad searches (e.g. a popular make with no other filters) where the normal result ceiling would otherwise cut off data.

💡 Set a **Max results** cap during testing, then raise it once you've confirmed your filters return the listings you expect.

### ❓ FAQ

**Do I need a mobile.de account or login to use this scraper?**
No. All data returned is public listing information — no account, login, or cookies are required.

**Can I search by multiple filters at the same time?**
Yes. Combine make, price, mileage, year, fuel type, transmission, body type, color, and location filters freely, or supply multiple search/listing URLs in a single run.

**Does it work for both cars and other vehicle categories?**
The scraper follows whatever category the search filters or URLs point to on mobile.de, including cars and other vehicle types listed on the marketplace.

**What if my search normally returns more results than a single search page shows?**
Enable Exhaustive mode. It automatically segments broad searches so you can pull well beyond the normal single-search result ceiling.

**Can I use this data with my AI agent or chatbot?**
Yes. Results are clean structured JSON, and the scraper is compatible with the Apify MCP server, so agents built on Claude, ChatGPT, or LangChain can query live vehicle data directly.

### 💳 Pricing

Pay only for results — no subscription required. Try it free.

### 🔗 Related Scrapers

Looking for other European marketplaces? Check out our other classifieds and marketplace scrapers for cross-market research, lead generation, and price monitoring across multiple countries and verticals.

# Actor input Schema

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

Paste one or more mobile.de search-result URLs (from suchen.mobile.de) or direct vehicle listing URLs. Optional — leave empty to use the filter fields below instead.

## `searchTerm` (type: `string`):

Free-text keyword search, e.g. "e36", "AMG", "sportback". Narrows results on top of any other filters.

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

Filter by vehicle make/brand. Pick from the list, or leave on "Any" and use Search term / Make ID instead for a brand not listed.

## `makeId` (type: `integer`):

mobile.de's internal numeric make ID. Overrides Make when set. Use this for a brand not in the Make dropdown (find the ID by inspecting a mobile.de search URL's ms= parameter).

## `modelId` (type: `integer`):

mobile.de's internal numeric model ID, used together with Make ID.

## `priceMin` (type: `integer`):

Minimum listing price in euros.

## `priceMax` (type: `integer`):

Maximum listing price in euros.

## `mileageMin` (type: `integer`):

Minimum mileage in kilometers.

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

Maximum mileage in kilometers.

## `yearMin` (type: `integer`):

Earliest first-registration year.

## `yearMax` (type: `integer`):

Latest first-registration year.

## `powerKwMin` (type: `integer`):

Minimum engine power in kilowatts.

## `powerKwMax` (type: `integer`):

Maximum engine power in kilowatts.

## `fuelType` (type: `array`):

Filter by fuel type. Select multiple to combine with OR.

## `transmission` (type: `array`):

Filter by transmission type. Select multiple to combine with OR.

## `vehicleType` (type: `array`):

Filter by body type. Select multiple to combine with OR.

## `exteriorColor` (type: `array`):

Filter by exterior color. Select multiple to combine with OR.

## `damagedOnly` (type: `string`):

Include or exclude damaged/accident vehicles.

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

Filter by dealer vs. private seller listings.

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

Restrict results to a listing country. Defaults to Germany.

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

German postal code to search around. Combine with Radius (km).

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

Search radius in kilometers around the ZIP code above.

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

Total cap on results across all search URLs / filters combined.

## `maxItemsPerQuery` (type: `integer`):

Cap results per individual search URL / filter set, instead of one shared total. Leave empty to only use Max results.

## `exhaustiveMode` (type: `boolean`):

mobile.de exposes at most ~2,000 results per exact search. When enabled, the actor automatically splits a search into price-range slices to pull past that ceiling for very broad searches.

## `includeFullDetails` (type: `boolean`):

Visit each listing's detail page for the complete spec sheet, equipment list, description and VIN-equivalent registration numbers (one extra request per result). Turn off for a faster, lighter run using search-result data only.

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

Datacenter proxy is used by default for reliability on large runs. Only change this if you have a specific proxy requirement.

## Actor input object example

```json
{
  "startUrls": [],
  "searchTerm": "",
  "make": "",
  "fuelType": [],
  "transmission": [],
  "vehicleType": [],
  "exteriorColor": [],
  "damagedOnly": "Any",
  "sellerType": "Any",
  "country": "DE",
  "zipCode": "",
  "maxItems": 200,
  "exhaustiveMode": false,
  "includeFullDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/mobile-de-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/mobile-de-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 '{}' |
apify call scrapesmith/mobile-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mobile.de Scraper",
        "description": "Scrape mobile.de car listings with 90+ data points. Price, mileage, power, specs, full dealer contact with WhatsApp, images, equipment list. Search by make, model, price range, or paste URLs. JSON/CSV/Excel. API, MCP, webhook, AI-agent ready.",
        "version": "0.0",
        "x-build-id": "vv8YQjBzvChAvUgfi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~mobile-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-mobile-de-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/scrapesmith~mobile-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-mobile-de-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/scrapesmith~mobile-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-mobile-de-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": "Search or listing URLs",
                        "type": "array",
                        "description": "Paste one or more mobile.de search-result URLs (from suchen.mobile.de) or direct vehicle listing URLs. Optional — leave empty to use the filter fields below instead.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "Free-text keyword search, e.g. \"e36\", \"AMG\", \"sportback\". Narrows results on top of any other filters.",
                        "default": ""
                    },
                    "make": {
                        "title": "Make",
                        "enum": [
                            "",
                            "Mercedes-Benz",
                            "BMW",
                            "Audi",
                            "Volkswagen",
                            "Porsche",
                            "Opel",
                            "Ford",
                            "Skoda",
                            "Seat",
                            "Toyota",
                            "Volvo",
                            "Renault",
                            "Peugeot",
                            "Citroen",
                            "Fiat",
                            "Mini",
                            "Mazda",
                            "Nissan",
                            "Hyundai",
                            "Kia",
                            "Honda",
                            "Suzuki",
                            "Mitsubishi",
                            "Jeep",
                            "Land Rover",
                            "Jaguar",
                            "Dacia",
                            "Alfa Romeo",
                            "Smart",
                            "Subaru",
                            "Chevrolet",
                            "Chrysler",
                            "Maserati",
                            "Lancia",
                            "Saab",
                            "Rolls-Royce"
                        ],
                        "type": "string",
                        "description": "Filter by vehicle make/brand. Pick from the list, or leave on \"Any\" and use Search term / Make ID instead for a brand not listed.",
                        "default": ""
                    },
                    "makeId": {
                        "title": "Make ID (advanced)",
                        "type": "integer",
                        "description": "mobile.de's internal numeric make ID. Overrides Make when set. Use this for a brand not in the Make dropdown (find the ID by inspecting a mobile.de search URL's ms= parameter)."
                    },
                    "modelId": {
                        "title": "Model ID (advanced)",
                        "type": "integer",
                        "description": "mobile.de's internal numeric model ID, used together with Make ID."
                    },
                    "priceMin": {
                        "title": "Price min (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price in euros."
                    },
                    "priceMax": {
                        "title": "Price max (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price in euros."
                    },
                    "mileageMin": {
                        "title": "Mileage min (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum mileage in kilometers."
                    },
                    "mileageMax": {
                        "title": "Mileage max (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum mileage in kilometers."
                    },
                    "yearMin": {
                        "title": "First registration year, from",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Earliest first-registration year."
                    },
                    "yearMax": {
                        "title": "First registration year, to",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Latest first-registration year."
                    },
                    "powerKwMin": {
                        "title": "Power min (kW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum engine power in kilowatts."
                    },
                    "powerKwMax": {
                        "title": "Power max (kW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum engine power in kilowatts."
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "type": "array",
                        "description": "Filter by fuel type. Select multiple to combine with OR.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PETROL",
                                "DIESEL",
                                "ELECTRICITY",
                                "HYBRID",
                                "HYBRID_DIESEL",
                                "LPG",
                                "CNG",
                                "HYDROGENIUM",
                                "ETHANOL",
                                "OTHER"
                            ],
                            "enumTitles": [
                                "Petrol",
                                "Diesel",
                                "Electric",
                                "Hybrid (Petrol)",
                                "Hybrid (Diesel)",
                                "LPG",
                                "Natural Gas (CNG)",
                                "Hydrogen",
                                "Ethanol",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "transmission": {
                        "title": "Transmission",
                        "type": "array",
                        "description": "Filter by transmission type. Select multiple to combine with OR.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "MANUAL_GEAR",
                                "AUTOMATIC_GEAR",
                                "SEMIAUTOMATIC_GEAR"
                            ],
                            "enumTitles": [
                                "Manual",
                                "Automatic",
                                "Semi-automatic"
                            ]
                        },
                        "default": []
                    },
                    "vehicleType": {
                        "title": "Vehicle / body type",
                        "type": "array",
                        "description": "Filter by body type. Select multiple to combine with OR.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Cabrio",
                                "EstateCar",
                                "OffRoad",
                                "Limousine",
                                "SmallCar",
                                "SportsCar",
                                "Van",
                                "OtherCar"
                            ],
                            "enumTitles": [
                                "Cabriolet / Roadster",
                                "Estate Car",
                                "Off-road / SUV / Pickup",
                                "Saloon",
                                "Small Car",
                                "Sports Car / Coupe",
                                "Van / Minibus",
                                "Other"
                            ]
                        },
                        "default": []
                    },
                    "exteriorColor": {
                        "title": "Exterior color",
                        "type": "array",
                        "description": "Filter by exterior color. Select multiple to combine with OR.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "BLACK",
                                "BEIGE",
                                "GREY",
                                "BROWN",
                                "WHITE",
                                "ORANGE",
                                "BLUE",
                                "YELLOW",
                                "RED",
                                "GREEN",
                                "SILVER",
                                "GOLD",
                                "PURPLE"
                            ],
                            "enumTitles": [
                                "Black",
                                "Beige",
                                "Grey",
                                "Brown",
                                "White",
                                "Orange",
                                "Blue",
                                "Yellow",
                                "Red",
                                "Green",
                                "Silver",
                                "Gold",
                                "Purple"
                            ]
                        },
                        "default": []
                    },
                    "damagedOnly": {
                        "title": "Vehicle condition",
                        "enum": [
                            "Any",
                            "false",
                            "true"
                        ],
                        "type": "string",
                        "description": "Include or exclude damaged/accident vehicles.",
                        "default": "Any"
                    },
                    "sellerType": {
                        "title": "Seller type",
                        "enum": [
                            "Any",
                            "Private"
                        ],
                        "type": "string",
                        "description": "Filter by dealer vs. private seller listings.",
                        "default": "Any"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "DE",
                            "AT",
                            "Any"
                        ],
                        "type": "string",
                        "description": "Restrict results to a listing country. Defaults to Germany.",
                        "default": "DE"
                    },
                    "zipCode": {
                        "title": "ZIP code",
                        "type": "string",
                        "description": "German postal code to search around. Combine with Radius (km).",
                        "default": ""
                    },
                    "radiusKm": {
                        "title": "Radius (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Search radius in kilometers around the ZIP code above."
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Total cap on results across all search URLs / filters combined.",
                        "default": 200
                    },
                    "maxItemsPerQuery": {
                        "title": "Max results per search (advanced)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Cap results per individual search URL / filter set, instead of one shared total. Leave empty to only use Max results."
                    },
                    "exhaustiveMode": {
                        "title": "Exhaustive mode",
                        "type": "boolean",
                        "description": "mobile.de exposes at most ~2,000 results per exact search. When enabled, the actor automatically splits a search into price-range slices to pull past that ceiling for very broad searches.",
                        "default": false
                    },
                    "includeFullDetails": {
                        "title": "Fetch full listing details",
                        "type": "boolean",
                        "description": "Visit each listing's detail page for the complete spec sheet, equipment list, description and VIN-equivalent registration numbers (one extra request per result). Turn off for a faster, lighter run using search-result data only.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Datacenter proxy is used by default for reliability on large runs. Only change this if you have a specific proxy requirement.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
