# Mobile De Vehicle Scraper (`crawlerbros/mobile-de-vehicle-scraper`) Actor

Scrape vehicle listings from mobile.de, Germany's largest online car marketplace. Filter by make, model, price, mileage, year, fuel type, transmission, and many more options. Extract comprehensive vehicle data including specifications, pricing, dealer information, and images.

- **URL**: https://apify.com/crawlerbros/mobile-de-vehicle-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Vehicle Scraper

Scrape vehicle listings from [mobile.de](https://www.mobile.de), Germany's largest online car marketplace. Extract comprehensive vehicle data including specifications, pricing, dealer information, and images.

### Features

- **Comprehensive Filters**: Search by make, model, price range, mileage, year, fuel type, transmission, body type, color, and many more options
- **Direct URL Support**: Paste any mobile.de search URL to scrape those exact results
- **Full Details Mode**: Optionally visit each vehicle page for complete specifications and all images
- **Pagination Support**: Automatically handles multiple pages of results
- **Anti-Detection**: Built-in measures to avoid bot detection

### Input Parameters

#### Search Filters

| Parameter | Type | Description |
|-----------|------|-------------|
| `searchUrl` | String | Direct mobile.de search URL (optional - overrides all other filters) |
| `make` | String | Car manufacturer (e.g., "BMW", "Mercedes-Benz", "Volkswagen") |
| `model` | String | Car model (e.g., "3 Series", "Golf") |
| `priceFrom` | Integer | Minimum price in EUR |
| `priceTo` | Integer | Maximum price in EUR |
| `mileageFrom` | Integer | Minimum mileage in km |
| `mileageTo` | Integer | Maximum mileage in km |
| `yearFrom` | Integer | Minimum first registration year |
| `yearTo` | Integer | Maximum first registration year |
| `fuelType` | Array | Fuel types: PETROL, DIESEL, ELECTRIC, HYBRID, HYBRID_PLUGIN, LPG, CNG, HYDROGEN |
| `transmission` | Array | Transmission: AUTOMATIC_GEAR, MANUAL_GEAR, SEMIAUTOMATIC_GEAR |
| `condition` | String | NEW, USED, EMPLOYEE_CAR, PRE_REGISTRATION, DEMONSTRATION, CLASSIC |
| `bodyType` | Array | Body types: Cabrio, EstateCar, Limousine, OffRoad, SmallCar, SportsCar, Van |
| `powerFrom` | Integer | Minimum power in kW |
| `powerTo` | Integer | Maximum power in kW |
| `sellerType` | String | DEALER or PRIVATE |
| `exteriorColor` | Array | Colors: BLACK, WHITE, SILVER, GREY, BLUE, RED, GREEN, etc. |
| `doors` | String | TWO_OR_THREE, FOUR_OR_FIVE, SIX_OR_MORE |
| `seatsFrom` | Integer | Minimum seats |
| `seatsTo` | Integer | Maximum seats |
| `driveType` | String | FRONT, REAR, ALL_WHEEL |
| `emissionClass` | String | EURO1 through EURO6D |
| `country` | String | Country code (DE, AT, CH, NL, BE, FR, IT, ES, PL) |
| `zipCode` | String | ZIP/postal code for location search |
| `radius` | Integer | Search radius in km from ZIP code |

#### Scraper Settings

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | Integer | 100 | Maximum number of vehicles to scrape |
| `sortBy` | String | "standard" | Sort order (price-asc, price-desc, mileage-asc, etc.) |
| `scrapeDetails` | Boolean | false | Visit each vehicle page for full details |
| `includeDamaged` | Boolean | false | Include vehicles with unrepaired damage |
| `vatDeductible` | Boolean | false | Only VAT-deductible vehicles |

### Output

Each vehicle in the output dataset contains:

```json
{
  "adId": "433184497",
  "title": "BMW 320d M Sport",
  "make": "BMW",
  "model": "320d",
  "price": "49.990 EUR",
  "priceAmount": 49990,
  "mileage": "25.800 km",
  "mileageKm": 25800,
  "firstRegistration": "03/2021",
  "fuelType": "Diesel",
  "transmission": "Automatic",
  "power": "140 kW (190 PS)",
  "powerKw": 140,
  "bodyType": "Limousine",
  "exteriorColor": "Black",
  "location": "80331 Munich",
  "sellerType": "DEALER",
  "url": "https://www.mobile.de/auto-inserat/-id433184497.html",
  "imageUrl": "https://img.classistatic.de/..."
}
````

With `scrapeDetails: true`, additional fields are included:

- `description`: Full vehicle description
- `images`: Array of all image URLs
- `features`: List of equipment/features
- `specifications`: Technical specifications object
- `sellerName`: Dealer/seller name
- `sellerAddress`: Seller location

### Example Input

#### Search for used BMW 3 Series

```json
{
  "make": "BMW",
  "model": "3 Series",
  "condition": "USED",
  "priceFrom": 20000,
  "priceTo": 50000,
  "yearFrom": 2019,
  "fuelType": ["DIESEL", "PETROL"],
  "transmission": ["AUTOMATIC_GEAR"],
  "maxResults": 50
}
```

#### Search for electric vehicles

```json
{
  "fuelType": ["ELECTRIC"],
  "priceFrom": 30000,
  "priceTo": 60000,
  "yearFrom": 2022,
  "maxResults": 100,
  "sortBy": "price-asc"
}
```

#### Use direct search URL

```json
{
  "searchUrl": "https://suchen.mobile.de/fahrzeuge/search.html?dam=0&isSearchRequest=true&ms=3500&maxPrice=50000",
  "maxResults": 200,
  "scrapeDetails": true
}
```

### Notes

- The scraper uses browser automation (Playwright) to render JavaScript-heavy pages
- Rate limiting is built-in to avoid overloading the server
- Results are returned as they are scraped, so partial results are available if scraping is interrupted
- mobile.de is a German website; some field values may be in German

### ⚠️ Important: Bot Detection

**mobile.de has strong bot detection measures** that may block automated access, especially to search result pages. The site employs:

- IP reputation checks
- TLS/SSL fingerprinting
- JavaScript-based bot detection
- Different protection levels for different pages (homepage vs search)

#### If You Encounter Access Denied (403) Errors:

1. **Enable Proxy** (`useProxy: true`) - Uses Apify residential proxy for better success rate
2. **Use Direct Search URLs** - Copy the exact URL from your browser after performing a search manually
3. **Reduce Request Volume** - Lower `maxResults` and add delays between requests
4. **Try Different Times** - Bot detection may be more strict during peak hours

#### Alternative Approaches:

If the scraper consistently fails due to bot detection, consider:

- **Mobile.de API**: Check if mobile.de offers an official API for programmatic access
- **Data Providers**: Consider third-party automotive data providers
- **Manual Export**: Use the site's built-in export/share features for smaller datasets

### Proxy Configuration

The scraper automatically uses Apify residential proxy when `useProxy: true`. This provides:

- Residential IP addresses
- Automatic IP rotation
- Better success rate against bot detection

**Note**: Residential proxy usage incurs additional costs on your Apify subscription.

### Legal Notice

This scraper is for personal/research use. Please review and comply with mobile.de's Terms of Service and robots.txt before using at scale. Automated scraping may be against the site's terms of service.

# Actor input Schema

## `searchUrl` (type: `string`):

Direct URL from mobile.de search results page. If provided, all other filters will be ignored. Example: https://suchen.mobile.de/fahrzeuge/search.html?dam=0\&isSearchRequest=true\&ms=3500

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

Car manufacturer/brand name (e.g., 'BMW', 'Mercedes-Benz', 'Volkswagen', 'Audi')

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

Car model name (e.g., '3 Series', 'C-Class', 'Golf'). Make must be specified.

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

Minimum price in EUR

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

Maximum price in EUR

## `mileageFrom` (type: `integer`):

Minimum mileage in kilometers

## `mileageTo` (type: `integer`):

Maximum mileage in kilometers

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

Minimum first registration year

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

Maximum first registration year

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

Filter by fuel type(s). Options: PETROL, DIESEL, ELECTRIC, HYBRID, HYBRID\_PLUGIN, LPG, CNG, HYDROGEN, ETHANOL

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

Filter by transmission type(s). Options: AUTOMATIC\_GEAR, MANUAL\_GEAR, SEMIAUTOMATIC\_GEAR

## `condition` (type: `string`):

Filter by vehicle condition

## `bodyType` (type: `array`):

Filter by body type(s). Options: Cabrio, EstateCar, Limousine, OffRoad, SmallCar, SportsCar, Van, Other

## `powerFrom` (type: `integer`):

Minimum power in kW

## `powerTo` (type: `integer`):

Maximum power in kW

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

Filter by seller type

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

Filter by exterior color(s). Options: BLACK, WHITE, SILVER, GREY, BLUE, RED, GREEN, BROWN, BEIGE, GOLD, ORANGE, YELLOW, VIOLET

## `doors` (type: `string`):

Filter by number of doors

## `seatsFrom` (type: `integer`):

Minimum number of seats

## `seatsTo` (type: `integer`):

Maximum number of seats

## `driveType` (type: `string`):

Filter by drive type

## `emissionClass` (type: `string`):

Filter by emission class

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

Filter by country (ISO 3166-1 alpha-2 code)

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

Search around a specific ZIP code

## `radius` (type: `integer`):

Search radius in kilometers from ZIP code. Common values: 10, 20, 30, 50, 75, 100, 150, 200. Use 0 for Germany-wide search.

## `includeDamaged` (type: `boolean`):

Include vehicles with unrepaired damage

## `vatDeductible` (type: `boolean`):

Only show vehicles where VAT is deductible (for businesses)

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

Maximum number of vehicle listings to scrape

## `sortBy` (type: `string`):

Sort order for results

## `scrapeDetails` (type: `boolean`):

Visit each vehicle page to scrape complete details including full description, all images, and dealer contact info. This is slower but provides more data.

## `useProxy` (type: `boolean`):

Use Apify residential proxy (recommended for avoiding bot detection). Requires Apify platform with proxy subscription.

## Actor input object example

```json
{
  "make": "BMW",
  "model": "3 Series",
  "country": "",
  "radius": 0,
  "includeDamaged": false,
  "vatDeductible": false,
  "maxResults": 100,
  "sortBy": "standard",
  "scrapeDetails": false,
  "useProxy": 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("crawlerbros/mobile-de-vehicle-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("crawlerbros/mobile-de-vehicle-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 crawlerbros/mobile-de-vehicle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mobile De Vehicle Scraper",
        "description": "Scrape vehicle listings from mobile.de, Germany's largest online car marketplace. Filter by make, model, price, mileage, year, fuel type, transmission, and many more options. Extract comprehensive vehicle data including specifications, pricing, dealer information, and images.",
        "version": "1.0",
        "x-build-id": "ZzNWvIw7O0OaXkGRn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~mobile-de-vehicle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-mobile-de-vehicle-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/crawlerbros~mobile-de-vehicle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-mobile-de-vehicle-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/crawlerbros~mobile-de-vehicle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-mobile-de-vehicle-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": {
                    "searchUrl": {
                        "title": "Search URL (Optional)",
                        "type": "string",
                        "description": "Direct URL from mobile.de search results page. If provided, all other filters will be ignored. Example: https://suchen.mobile.de/fahrzeuge/search.html?dam=0&isSearchRequest=true&ms=3500"
                    },
                    "make": {
                        "title": "Make (Brand)",
                        "type": "string",
                        "description": "Car manufacturer/brand name (e.g., 'BMW', 'Mercedes-Benz', 'Volkswagen', 'Audi')"
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Car model name (e.g., '3 Series', 'C-Class', 'Golf'). Make must be specified."
                    },
                    "priceFrom": {
                        "title": "Price From (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price in EUR"
                    },
                    "priceTo": {
                        "title": "Price To (EUR)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in EUR"
                    },
                    "mileageFrom": {
                        "title": "Mileage From (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum mileage in kilometers"
                    },
                    "mileageTo": {
                        "title": "Mileage To (km)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum mileage in kilometers"
                    },
                    "yearFrom": {
                        "title": "First Registration From (Year)",
                        "minimum": 1900,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Minimum first registration year"
                    },
                    "yearTo": {
                        "title": "First Registration To (Year)",
                        "minimum": 1900,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Maximum first registration year"
                    },
                    "fuelType": {
                        "title": "Fuel Type",
                        "type": "array",
                        "description": "Filter by fuel type(s). Options: PETROL, DIESEL, ELECTRIC, HYBRID, HYBRID_PLUGIN, LPG, CNG, HYDROGEN, ETHANOL",
                        "items": {
                            "type": "string"
                        }
                    },
                    "transmission": {
                        "title": "Transmission",
                        "type": "array",
                        "description": "Filter by transmission type(s). Options: AUTOMATIC_GEAR, MANUAL_GEAR, SEMIAUTOMATIC_GEAR",
                        "items": {
                            "type": "string"
                        }
                    },
                    "condition": {
                        "title": "Vehicle Condition",
                        "enum": [
                            "",
                            "NEW",
                            "USED",
                            "EMPLOYEE_CAR",
                            "PRE_REGISTRATION",
                            "DEMONSTRATION",
                            "CLASSIC"
                        ],
                        "type": "string",
                        "description": "Filter by vehicle condition"
                    },
                    "bodyType": {
                        "title": "Body Type",
                        "type": "array",
                        "description": "Filter by body type(s). Options: Cabrio, EstateCar, Limousine, OffRoad, SmallCar, SportsCar, Van, Other",
                        "items": {
                            "type": "string"
                        }
                    },
                    "powerFrom": {
                        "title": "Power From (kW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum power in kW"
                    },
                    "powerTo": {
                        "title": "Power To (kW)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum power in kW"
                    },
                    "sellerType": {
                        "title": "Seller Type",
                        "enum": [
                            "",
                            "DEALER",
                            "PRIVATE"
                        ],
                        "type": "string",
                        "description": "Filter by seller type"
                    },
                    "exteriorColor": {
                        "title": "Exterior Color",
                        "type": "array",
                        "description": "Filter by exterior color(s). Options: BLACK, WHITE, SILVER, GREY, BLUE, RED, GREEN, BROWN, BEIGE, GOLD, ORANGE, YELLOW, VIOLET",
                        "items": {
                            "type": "string"
                        }
                    },
                    "doors": {
                        "title": "Number of Doors",
                        "enum": [
                            "",
                            "TWO_OR_THREE",
                            "FOUR_OR_FIVE",
                            "SIX_OR_MORE"
                        ],
                        "type": "string",
                        "description": "Filter by number of doors"
                    },
                    "seatsFrom": {
                        "title": "Seats From",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Minimum number of seats"
                    },
                    "seatsTo": {
                        "title": "Seats To",
                        "minimum": 1,
                        "maximum": 9,
                        "type": "integer",
                        "description": "Maximum number of seats"
                    },
                    "driveType": {
                        "title": "Drive Type",
                        "enum": [
                            "",
                            "FRONT",
                            "REAR",
                            "ALL_WHEEL"
                        ],
                        "type": "string",
                        "description": "Filter by drive type"
                    },
                    "emissionClass": {
                        "title": "Emission Class",
                        "enum": [
                            "",
                            "EURO1",
                            "EURO2",
                            "EURO3",
                            "EURO4",
                            "EURO5",
                            "EURO6",
                            "EURO6C",
                            "EURO6D",
                            "EURO6D_TEMP"
                        ],
                        "type": "string",
                        "description": "Filter by emission class"
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "DE",
                            "AT",
                            "CH",
                            "NL",
                            "BE",
                            "FR",
                            "IT",
                            "ES",
                            "PL"
                        ],
                        "type": "string",
                        "description": "Filter by country (ISO 3166-1 alpha-2 code)",
                        "default": ""
                    },
                    "zipCode": {
                        "title": "ZIP/Postal Code",
                        "type": "string",
                        "description": "Search around a specific ZIP code"
                    },
                    "radius": {
                        "title": "Search Radius (km)",
                        "minimum": 0,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Search radius in kilometers from ZIP code. Common values: 10, 20, 30, 50, 75, 100, 150, 200. Use 0 for Germany-wide search.",
                        "default": 0
                    },
                    "includeDamaged": {
                        "title": "Include Damaged Vehicles",
                        "type": "boolean",
                        "description": "Include vehicles with unrepaired damage",
                        "default": false
                    },
                    "vatDeductible": {
                        "title": "VAT Deductible",
                        "type": "boolean",
                        "description": "Only show vehicles where VAT is deductible (for businesses)",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of vehicle listings to scrape",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "standard",
                            "price-asc",
                            "price-desc",
                            "mileage-asc",
                            "mileage-desc",
                            "registration-desc",
                            "registration-asc",
                            "power-desc",
                            "power-asc"
                        ],
                        "type": "string",
                        "description": "Sort order for results",
                        "default": "standard"
                    },
                    "scrapeDetails": {
                        "title": "Scrape Full Details",
                        "type": "boolean",
                        "description": "Visit each vehicle page to scrape complete details including full description, all images, and dealer contact info. This is slower but provides more data.",
                        "default": false
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Use Apify residential proxy (recommended for avoiding bot detection). Requires Apify platform with proxy subscription.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
