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

Scrape vehicle listings from Mobile.de, Germany's largest car marketplace. Get make, model, price, mileage, registration, power, fuel, transmission, equipment and photos, plus the dealer name, phone, address and exact GPS on every listing. Search by URL or filters and export to JSON, CSV or Excel.

- **URL**: https://apify.com/silentflow/mobile-de-scraper.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** E-commerce, 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.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

## Mobile.de Scraper

**Turn every listing on Germany's largest vehicle marketplace into clean, structured data. 500 vehicles per run in under a minute, with dealer phone, address and GPS on every record.**

Mobile.de lists more than 1.5 million cars, motorbikes, vans, trucks and motorhomes across Germany and Europe. This scraper pulls that inventory into ready-to-use JSON, CSV or Excel: make, model, price, mileage, full technical specs, the complete equipment list, every photo, and the selling dealer with contact details and map coordinates. Paste a search URL or set a few filters, press start, and get structured results you can drop straight into a spreadsheet, a database, or a model.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/sKfsey7znjBhuknVJ/records/how-it-works-v1.png)

### ✨ Why teams choose this over other Mobile.de scrapers

Shopping around for used-car data and getting half-empty rows back? Running a scraper that breaks every time mobile.de ships a redesign? Paying for results that skip the one field you actually needed?

- 🏷️ **Every record carries the dealer, not just the car.** Name, street address, phone number, and exact GPS latitude and longitude come on every single listing, plus the dealer's star rating and review count. Most scrapers give you the car and make you guess who is selling it.
- 🧾 **The full equipment list, not a summary.** Each vehicle ships with its complete feature list (often 40 to 60 items: driver assistance, comfort, safety, infotainment) exactly as the seller entered it, so you can filter on the exact options buyers ask for.
- 💶 **The mobile.de price rating is included.** When the marketplace rates a price against the market, you get that rating and its label, so you can spot the good deals without building your own valuation model.
- 🔎 **Search by URL or by filters.** Configure a precise search on mobile.de and paste the link, or skip the site entirely and set category, make, model, price, mileage, year and fuel right here. Both paths hit the same rich data.
- 🌍 **Every category, not just cars.** Cars, motorbikes, vans, trucks, semi-trailer trucks, motorhomes, construction machines and trailers all work with the same input.
- 📐 **Clean, typed JSON.** Mileage is a number, power comes as both kW and HP, coordinates are floats, dates are ISO timestamps. No scraping HTML out of a text blob on your side.
- 🔁 **Structured for automation.** No login, no API key, no browser extension. Feed the output straight into Google Sheets, a warehouse, or a pricing pipeline.

### 🎯 What you can do with Mobile.de data

| Team | What they build |
|---|---|
| Used-car dealers | Track competitor pricing on the exact make, model and year you stock, and reprice daily |
| Car-buying services | Surface underpriced listings by comparing each car's price rating against the market |
| Lead generation | Build dealer call lists with name, phone, address and GPS, filtered by region and inventory size |
| Market analysts | Measure depreciation curves and regional price gaps across hundreds of thousands of listings |
| Fleet and leasing | Source vehicles by mileage, registration year and equipment, then rank by total value |
| Insurers and valuation | Feed real listing prices, KBA type codes and specs into pricing and risk models |
| Parts and salvage | Find damage cases and non-runners by category and location for parts sourcing |
| Data and ML teams | Assemble labelled vehicle datasets (specs, photos, prices) for training and analysis |

### 📥 Input parameters

#### Search by URL

| Field | Type | Description |
|---|---|---|
| `searchUrls` | array | Mobile.de search result URLs or individual listing URLs. Paste as many as you like. |

#### Search by filters (used when no URL is given)

| Field | Type | Description |
|---|---|---|
| `searchCategory` | select | Cars, Motorbikes, Vans, Trucks, Semi-trailer trucks, Motorhomes, Construction machines, Trailers |
| `models` | array | Make and model by mobile.de id, e.g. `3500` (BMW) or `3500\|20` (make and model) |
| `priceMin` / `priceMax` | integer | Price range in euros |
| `mileageKmMin` / `mileageKmMax` | integer | Mileage range in kilometres |
| `registrationYearMin` / `registrationYearMax` | integer | First-registration year range |
| `fuelType` | array | Petrol, Diesel, Electric, Hybrid, LPG, CNG, Hydrogen, Ethanol |
| `sort` | select | Relevance, Price, Mileage, Newest, Registration |

#### Limits and options

| Field | Type | Description |
|---|---|---|
| `maxItems` | integer | Maximum number of listings to collect |
| `includeDetails` | boolean | Fetch each listing's full record (description, equipment, all photos, technical attributes). On by default |
| `proxyConfiguration` | object | Optional proxy. Off by default |
| `debugMode` | boolean | Show detailed logs |

### 📊 Output data

Each listing is one JSON object. A search result enriched with its full detail record looks like this:

```json
{
  "id": "459256404",
  "url": "https://suchen.mobile.de/auto-inserat/land-rover-discovery-koeln/459256404.html",
  "title": "Land Rover Discovery 3.0 SDV6 HSE",
  "make": "Land Rover",
  "model": "Discovery",
  "makeId": "14800",
  "modelId": "3",
  "category": "OffRoad",
  "vehicleClass": "Car",
  "price": { "amount": 15900, "currency": "EUR", "localized": "15.900 €", "type": "FIXED" },
  "priceRating": { "rating": "GOOD_PRICE", "label": "Good price" },
  "firstRegistration": "07/2012",
  "mileageKm": 219000,
  "powerKw": 180,
  "powerHp": 245,
  "fuelType": "Diesel",
  "transmission": "Automatik",
  "displacementCc": 2993,
  "exteriorColor": "Schwarz",
  "doors": "4/5",
  "seats": "5",
  "hasDamage": false,
  "features": ["ABS", "Allradantrieb", "Navigationssystem", "Sitzheizung", "Anhängerkupplung"],
  "attributes": [
    { "label": "Kategorie", "value": "SUV/Geländewagen/Pickup" },
    { "label": "Ausstattungslinie", "value": "HSE" }
  ],
  "images": ["https://img.classistatic.de/api/v1/mo-prod/images/46/469f4983.jpg"],
  "location": { "country": "DE", "zip": "51145", "city": "Köln" },
  "dealer": {
    "name": "AMG Logistik GmbH",
    "type": "Händler",
    "address": "Waldstraße 125, DE-51145 Köln",
    "phone": "+49 (0)2203 9179797",
    "latitude": 50.8824119,
    "longitude": 7.0928372,
    "ratingScore": 4.4,
    "ratingCount": 5,
    "ratingLink": "https://www.mobile.de/bewertungen/AMGLogistikGmbH"
  },
  "kba": { "hsn": "2143", "tsn": "AAY" },
  "createdAt": "2026-06-27T10:52:08Z",
  "scrapedAt": "2026-07-04T12:34:06Z"
}
````

When `includeDetails` is off, you still get every search-level field, including the full dealer block with GPS and rating. The detail step adds `description`, the complete `features` list, `attributes`, `kba` codes, and the full photo set.

### 🗂️ Data fields

| Category | Fields |
|---|---|
| Identity | `id`, `url`, `title`, `shortTitle`, `subTitle` |
| Vehicle | `make`, `model`, `makeId`, `modelId`, `category`, `vehicleClass` |
| Price | `price.amount`, `price.currency`, `price.localized`, `price.type`, `priceRating.rating`, `priceRating.label` |
| Specs | `firstRegistration`, `mileageKm`, `powerKw`, `powerHp`, `fuelType`, `transmission`, `displacementCc`, `exteriorColor`, `doors`, `seats` |
| Condition | `condition`, `hasDamage`, `isDamageCase`, `readyToDrive`, `isNew` |
| Content | `description`, `features[]`, `attributes[]`, `images[]` |
| Location | `location.country`, `location.zip`, `location.city` |
| Dealer | `dealer.name`, `dealer.type`, `dealer.address`, `dealer.phone`, `dealer.latitude`, `dealer.longitude`, `dealer.ratingScore`, `dealer.ratingCount`, `dealer.ratingLink` |
| Registration codes | `kba.hsn`, `kba.tsn` |
| Timestamps | `createdAt`, `modifiedAt`, `scrapedAt` |

### 🚀 Examples

**Scrape all BMWs under 20,000 euros registered from 2016**
Set `searchCategory` to Cars, `models` to `3500`, `priceMax` to `20000`, `registrationYearMin` to `2016`.

**Pull a saved mobile.de search**
Configure the search on mobile.de, copy the address bar URL, paste it into `searchUrls`.

**Build a dealer lead list in one region**
Set a search URL scoped to a postcode area, keep `includeDetails` on, then filter the output by `dealer` to get name, phone, address and coordinates.

**Find damage cases and non-runners for parts**
Set `searchCategory` to Cars and sort by price ascending, then filter output on `hasDamage` and `readyToDrive`.

**Track a single listing over time**
Paste a listing URL into `searchUrls` and run on a schedule to watch price and status changes.

### 🤖 Copy to your AI assistant

```
Use the Mobile.de Scraper on Apify to collect vehicle listings.
Input: either a "searchUrls" array of mobile.de search or listing URLs, or
filters: searchCategory (Car/Motorbike/Van/Truck/Motorhome/...), models (mobile.de
make id, optionally "makeId|modelId"), priceMin/priceMax, mileageKmMin/mileageKmMax,
registrationYearMin/registrationYearMax, fuelType, sort, maxItems, includeDetails.
Each result has: make, model, price + priceRating, mileageKm, powerKw/powerHp,
fuelType, transmission, features[], attributes[], images[], location{country,zip,city},
dealer{name,phone,address,latitude,longitude,ratingScore}, kba{hsn,tsn}.
Help me set the input for: <describe the vehicles you want>.
```

### 💻 Integrations

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("YOUR_USERNAME/mobile-de-scraper").call(run_input={
    "searchCategory": "Car",
    "models": ["3500"],
    "priceMax": 20000,
    "registrationYearMin": 2016,
    "maxItems": 200,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["make"], item["model"], item["price"]["localized"], item["dealer"]["phone"])
```

**JavaScript**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('YOUR_USERNAME/mobile-de-scraper').call({
    searchUrls: [{ url: 'https://suchen.mobile.de/fahrzeuge/search.html?vc=Car&ms=3500%3B%3B%3B' }],
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((v) => console.log(v.make, v.model, v.mileageKm, v.location.city));
```

**Google Sheets and BI tools**
Export the dataset as CSV or connect the Apify dataset API to Google Sheets, Looker Studio or Power BI to build live dashboards of pricing and inventory.

### 📈 Performance

| Metric | Value |
|---|---|
| Results per search request | up to 500 |
| Typical listing-only speed | hundreds of results in under a minute |
| With full details | each listing fetched individually for the complete record |
| Categories supported | cars, motorbikes, vans, trucks, semi-trailer trucks, motorhomes, machines, trailers |
| Coverage | Germany plus other European listings on mobile.de |

Runtime scales with `maxItems` and whether `includeDetails` is on. For a quick scan, turn details off and keep the rich search fields, including full dealer contact.

### 💾 Data export

Results are available as JSON, JSONL, CSV, Excel, HTML table, RSS and XML through the Apify Console or the API. Every run stores its dataset so you can re-download or stream it into your own tools at any time.

### 💡 Tips for best results

- **Start from a mobile.de search URL** when you need precise filters. Everything you can pick on the site (region, equipment, seller type) carries over.
- **Turn off `includeDetails` for a fast first pass**, then re-run with details on for the listings you care about. The search results already include price, specs and full dealer contact.
- **Use `models` ids for exact matching.** A bare make id like `3500` returns the whole brand; add a model id (`3500|20`) to narrow it down.
- **Raise `maxItems` gradually** to keep runs quick while you tune your filters.
- **Combine filters** (year plus mileage plus fuel) to cut a 1.5 million listing marketplace down to the few hundred vehicles that matter.

### ❓ FAQ

**What vehicle types can I scrape?**
Cars, motorbikes, vans, trucks, semi-trailer trucks, motorhomes, construction machines and trailers.

**Do I need a mobile.de account or API key?**
No. Provide a search URL or filters and run the actor.

**Can I scrape a specific search I already set up?**
Yes. Copy the URL from your browser after running the search on mobile.de and paste it into `searchUrls`.

**Does it return the dealer's contact details?**
Yes. Every listing includes the dealer name, address, phone number, GPS coordinates, and rating where the seller is a dealer. Private sellers return the fields the marketplace exposes.

**Does it include individual dealer reviews?**
The output includes the dealer's aggregate rating (score and review count) and a link to their reviews page. Individual review texts are not part of a listing record.

**Can I get all photos of a car?**
Yes. With `includeDetails` on, the full photo set is returned as direct image URLs.

**What is the price rating?**
When mobile.de has enough comparable data, it rates a listing's price against the market. That rating and its label are included. Some listings have no rating, which is reported honestly rather than guessed.

**Are prices numbers or text?**
Both. `price.amount` is a number and `price.localized` is the formatted string shown on the site.

**What are the KBA codes?**
`hsn` and `tsn` are the German vehicle registration type codes, useful for exact model identification and parts matching.

**Can I run this on a schedule?**
Yes. Use Apify Schedules to run daily or hourly and track price and inventory changes over time.

### ⚖️ Legal

This scraper collects data that mobile.de publishes openly, without logging in. Use it responsibly and in line with applicable law. When your results include personal data (for example a private seller's name or phone number), you are the data controller and are responsible for a lawful basis and for honouring data-subject rights under the GDPR, the CCPA, and similar regulations. Do not use scraped contact details for unsolicited outreach where that is prohibited. Review mobile.de's terms and your own legal obligations before large-scale collection.

### 🔗 Related scrapers

Looking for other vehicle marketplaces? Explore our other automotive and classifieds scrapers on Apify to cover more inventory across Europe.

### 📬 Support

Have a use case that needs a field we do not return yet, or a search that behaves unexpectedly? Reach out through the actor's Apify page and we will help you get the data you need.

# Actor input Schema

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

Mobile.de search result URLs or individual listing URLs.

## `searchCategory` (type: `string`):

Type of vehicle to search for.

## `models` (type: `array`):

Filter by make and model. Use the mobile.de make id, optionally with a model id, e.g. "3500" (BMW) or "3500|20" (BMW 3 Series).

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

Lowest price to include.

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

Highest price to include.

## `mileageKmMin` (type: `integer`):

Lowest mileage to include.

## `mileageKmMax` (type: `integer`):

Highest mileage to include.

## `registrationYearMin` (type: `integer`):

Earliest first-registration year.

## `registrationYearMax` (type: `integer`):

Latest first-registration year.

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

Filter by fuel type.

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

Order of the results.

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

The maximum number of listings to collect.

## `includeDetails` (type: `boolean`):

Fetch each listing's full record (description, equipment, all photos, technical attributes). Turn off for faster, lighter results.

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

Optional proxy. Enable only if you run very large jobs.

## `debugMode` (type: `boolean`):

Show detailed logs.

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://suchen.mobile.de/fahrzeuge/search.html?vc=Car"
    }
  ],
  "searchCategory": "Car",
  "sort": "relevance",
  "maxItems": 50,
  "includeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "debugMode": false
}
```

# Actor output Schema

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

Scraped vehicle listings with full details.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchUrls": [
        {
            "url": "https://suchen.mobile.de/fahrzeuge/search.html?vc=Car"
        }
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/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 = {
    "searchUrls": [{ "url": "https://suchen.mobile.de/fahrzeuge/search.html?vc=Car" }],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/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 '{
  "searchUrls": [
    {
      "url": "https://suchen.mobile.de/fahrzeuge/search.html?vc=Car"
    }
  ],
  "maxItems": 50
}' |
apify call silentflow/mobile-de-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mobile.de Scraper",
        "description": "Scrape vehicle listings from Mobile.de, Germany's largest car marketplace. Get make, model, price, mileage, registration, power, fuel, transmission, equipment and photos, plus the dealer name, phone, address and exact GPS on every listing. Search by URL or filters and export to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "oRPx2CAcPCsAXugfQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~mobile-de-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-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/silentflow~mobile-de-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-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/silentflow~mobile-de-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-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": {
                    "searchUrls": {
                        "title": "Search or listing URLs",
                        "type": "array",
                        "description": "Mobile.de search result URLs or individual listing URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchCategory": {
                        "title": "Vehicle category",
                        "enum": [
                            "Car",
                            "Motorbike",
                            "VanUpTo7500",
                            "TruckOver7500",
                            "SemiTrailerTruck",
                            "Motorhome",
                            "ConstructionMachine",
                            "Trailer"
                        ],
                        "type": "string",
                        "description": "Type of vehicle to search for.",
                        "default": "Car"
                    },
                    "models": {
                        "title": "Makes and models",
                        "type": "array",
                        "description": "Filter by make and model. Use the mobile.de make id, optionally with a model id, e.g. \"3500\" (BMW) or \"3500|20\" (BMW 3 Series).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceMin": {
                        "title": "Minimum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest price to include."
                    },
                    "priceMax": {
                        "title": "Maximum price (€)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest price to include."
                    },
                    "mileageKmMin": {
                        "title": "Minimum mileage (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest mileage to include."
                    },
                    "mileageKmMax": {
                        "title": "Maximum mileage (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest mileage to include."
                    },
                    "registrationYearMin": {
                        "title": "Minimum registration year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Earliest first-registration year."
                    },
                    "registrationYearMax": {
                        "title": "Maximum registration year",
                        "minimum": 1900,
                        "type": "integer",
                        "description": "Latest first-registration year."
                    },
                    "fuelType": {
                        "title": "Fuel type",
                        "type": "array",
                        "description": "Filter by fuel type.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "PETROL",
                                "DIESEL",
                                "ELECTRICITY",
                                "HYBRID",
                                "HYBRID_DIESEL",
                                "LPG",
                                "CNG",
                                "HYDROGENIUM",
                                "ETHANOL"
                            ],
                            "enumTitles": [
                                "Petrol",
                                "Diesel",
                                "Electric",
                                "Hybrid (petrol)",
                                "Hybrid (diesel)",
                                "LPG",
                                "CNG",
                                "Hydrogen",
                                "Ethanol"
                            ]
                        }
                    },
                    "sort": {
                        "title": "Sort results",
                        "enum": [
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "mileage-asc",
                            "mileage-desc",
                            "date",
                            "registration-desc"
                        ],
                        "type": "string",
                        "description": "Order of the results.",
                        "default": "relevance"
                    },
                    "maxItems": {
                        "title": "Maximum number of results",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "The maximum number of listings to collect.",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Collect full details",
                        "type": "boolean",
                        "description": "Fetch each listing's full record (description, equipment, all photos, technical attributes). Turn off for faster, lighter results.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy. Enable only if you run very large jobs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Show detailed logs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
