# All Vehicle Scraper (`agentx/all-vehicle-scraper`) Actor

Search 52 country-aware vehicle marketplaces, classifieds, dealer inventories, and auction sources by keyword and optional native location. Export 35 normalized listing fields with source URLs.

- **URL**: https://apify.com/agentx/all-vehicle-scraper.md
- **Developed by:** [AgentX](https://apify.com/agentx) (community)
- **Categories:** E-commerce, Lead generation, Agents
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

**All Vehicle Scraper is a vehicle listings API for searching 52 country-aware marketplaces, classifieds, dealer inventories, and auction sources with one input.** Choose a country, enter a vehicle keyword, and optionally narrow the run by platform or source-native location. Each result follows one 35-field schema for prices, mileage, vehicle details, sellers, images, and source URLs.

The Actor is designed for automotive market research, dealer inventory monitoring, price comparison, auction discovery, and listing-data workflows. It is not a vehicle-history report, appraisal service, or private dealer database; output reflects the public fields returned by the selected sources at run time.

> **Referral disclosure:** Some Apify links in this README include the `fpr=aiagentapi` referral parameter.

[**Run a one-result test**](https://apify.com/agentx/all-vehicle-scraper?fpr=aiagentapi) · [**View the API page**](https://apify.com/agentx/all-vehicle-scraper/api?fpr=aiagentapi)

For the smallest useful test, select one platform and set `max_results` to `1`. On the FREE tier, one published result plus Actor Start costs at most **$0.01850**. The Store and API destinations returned HTTP 404 during the July 21, 2026 audit, so verify publication before relying on these links.

---

### Why Choose This API

#### One Vehicle Search Across 52 Sources

Use one five-field input instead of configuring a separate workflow for every marketplace. Country-aware platform selection covers 28 supported countries and regions, while the optional `platforms` field lets you target one or more compatible sources.

#### Source-Native Keyword and Location Search

The required `keyword` is used as the vehicle search phrase. The optional `location` is used only by platforms that can apply that location to their own search; platforms that cannot honor a supplied location are not represented as location-filtered results.

#### One 35-Field Vehicle Dataset

Results use the same field names across sources. Vehicle identity, price, mileage, seller, condition, specifications, images, listing dates, and source links remain in predictable columns, which means you can compare records without maintaining a separate output mapping for each marketplace.

#### Verifiable Listing Sources

Each publishable record includes a listing URL. When a source does not provide a particular optional value, that field remains empty instead of being filled with an inferred vehicle fact.

#### Pay Only for Published Results

The `result` event is charged for each vehicle listing written to the default Dataset. A separate Actor Start event is charged when the run starts.

---

### Quick Start Guide

#### How to Search Vehicle Listings in 3 Steps

##### Step 1: Configure Your Search

Select `country`, enter `keyword`, and set `max_results`. Optionally select `platforms` or enter a city, region, postcode, ZIP code, or local area in `location`.

##### Step 2: Run the Actor

Click **Start**. Leave `platforms` empty to use all compatible sources for the selected country and location.

##### Step 3: Export Your Dataset

Open the default Dataset to review vehicle records or export them through the formats and API options available on Apify.

#### Example Input

```json
{
  "country": "United States",
  "keyword": "Toyota Camry",
  "platforms": ["Cars.com"],
  "max_results": 1
}
````

***

### Input Parameters

#### Configuration Fields

| Parameter | Type | Required | Description | Example |
| --- | --- | --- | --- | --- |
| `country` | string | Yes | Country or region used to select compatible vehicle sources. | `"United States"` |
| `keyword` | string | Yes | Vehicle search phrase. Surrounding whitespace is removed; terms are not added, translated, or replaced. | `"2020 Toyota Camry"` |
| `platforms` | array | No | Optional source allowlist. Leave empty to use all compatible platforms. | `["CarGurus"]` |
| `location` | string | No | Optional city, region, postal code, ZIP code, or local area for sources that support it. | `"Los Angeles, CA"` |
| `max_results` | integer | Yes | Maximum number of published vehicle listings per selected platform, from 1 to 10,000. | `50` |

Only `country`, `keyword`, and `max_results` are required. `platforms` and `location` have no non-empty default.

#### Supported Countries and Regions

Australia, Brazil, Canada, Egypt, France, Germany, Greece, Hong Kong, India, Indonesia, Italy, Mainland China, Malaysia, Moldova, Morocco, Netherlands, Pakistan, Philippines, Poland, Portugal, Russia, Singapore, Spain, Turkey, Ukraine, United Kingdom, United States, and Vietnam.

#### Supported Vehicle Sources

The current public input includes these 52 labels:

28car, 999.md, Arabam, Auto.it, Auto.ru, Autohome, Automobile.it, AutoScout24, AutoTrader.ca, Auto Trader UK, Autotrader US, Avito Morocco, Avito Russia, car.gr, CarDekho, CARFAX, CarGurus, Carlist.my, CarMax, Carmudi Philippines, Cars.com, CARS24, carsales, CarsGuide, Carvana, CarWale, Cho Tot, Coches.net, Copart, Craigslist Cars & Trucks, Dongchedi, Drom.ru, Dubizzle Egypt, eBay Motors, Edmunds, IAA, Kelley Blue Book, La Centrale, Leboncoin, Marktplaats, mobile.de, Motorist.sg, OLX Pakistan, OLX Poland, OLX Ukraine, Oto, Otomoto, sgCarMart, Standvirtual, Subito, TrueCar, and Webmotors.

Platform availability depends on the selected country. A supplied platform must support that country, and a supplied location must be usable by at least one selected source.

***

### Output Data Schema

#### Complete Vehicle Record Structure

Each result uses 33 normalized vehicle fields plus `processor` and `processed_at`, for 35 fields in total.

#### Listing, Price, and Vehicle Fields

| Field | Type | Description |
| --- | --- | --- |
| `main_image` | string or null | Primary vehicle image URL. |
| `title` | string or null | Source listing title. |
| `price` | number or null | Parsed numeric asking price. |
| `currency` | string or null | Currency code or label provided by the source. |
| `price_text` | string or null | Source-formatted price text. |
| `year` | integer or null | Vehicle model year. |
| `make` | string or null | Vehicle manufacturer. |
| `model` | string or null | Vehicle model. |
| `trim` | string or null | Vehicle trim or variant. |
| `condition` | string or null | Listing condition such as new or used. |
| `body_type` | string or null | Body style such as sedan, SUV, or hatchback. |
| `fuel` | string or null | Fuel or powertrain label. |
| `transmission` | string or null | Transmission label. |
| `engine` | string or null | Engine description. |
| `drive_type` | string or null | Drivetrain label. |
| `exterior_color` | string or null | Exterior color. |
| `interior_color` | string or null | Interior color. |
| `mileage` | integer or null | Parsed mileage value. |
| `mileage_unit` | string or null | Mileage unit such as `mi` or `km`. |
| `vin` | string or null | Vehicle identification number when published by the source. |

#### Seller, Location, and Source Fields

| Field | Type | Description |
| --- | --- | --- |
| `location` | string or null | Listing location text. |
| `country` | string or null | Listing country when supplied by the source. |
| `seller` | string or null | Seller or dealer name. |
| `seller_type` | string or null | Seller classification when available. |
| `listing_id` | string or null | Source listing identifier. |
| `posted_at` | string or null | Source posting date or time. |
| `updated_at` | string or null | Source update date or time. |
| `description` | string or null | Listing description. |
| `images` | array | Vehicle image URLs. |
| `platform` | string or null | Vehicle source label. |
| `source_url` | string or null | Original listing URL used to verify the record. |
| `platform_url` | string or null | Platform listing URL when available. |
| `official_url` | string or null | Official outbound URL when explicitly supplied. |
| `processor` | string or null | Processor attribution URL recorded with the result. |
| `processed_at` | string or null | UTC processing timestamp. |

#### Example JSON Output

```json
{
  "main_image": "https://example.com/images/toyota-camry.jpg",
  "title": "2021 Toyota Camry XLE",
  "price": 24500,
  "currency": "USD",
  "year": 2021,
  "make": "Toyota",
  "model": "Camry",
  "trim": "XLE",
  "mileage": 58200,
  "mileage_unit": "mi",
  "location": "Los Angeles, CA",
  "country": "United States",
  "platform": "Cars.com",
  "source_url": "https://www.cars.com/vehicledetail/example/",
  "seller": "Example Toyota",
  "seller_type": "dealer",
  "condition": "Used",
  "body_type": "Sedan",
  "fuel": "Hybrid",
  "transmission": "Automatic",
  "engine": "2.5L I4",
  "drive_type": "FWD",
  "exterior_color": "White",
  "interior_color": "Black",
  "vin": "JTDKARFU3H3530090",
  "listing_id": "188403446",
  "posted_at": "2026-07-19",
  "updated_at": "2026-07-20",
  "description": "One-owner sedan with hybrid drivetrain.",
  "images": ["https://example.com/images/toyota-camry.jpg"],
  "price_text": "$24,500",
  "platform_url": "https://www.cars.com/vehicledetail/example/",
  "official_url": null,
  "processor": "https://apify.com/username/actor_name",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

#### Export and API Access

Apify Datasets can be downloaded in JSON, CSV, Excel, XML, RSS, and JSONL formats or accessed through the [Apify Dataset API](https://docs.apify.com/api/v2#/reference/datasets).

***

### Integration Examples

#### REST API

The intended owner/name identifier is `agentx/all-vehicle-scraper`. The public Store and API pages returned HTTP 404 on July 21, 2026, so this README does not invent a numeric Actor ID or reuse legacy online statistics.

After publication, this request runs the same one-result Cars.com scenario synchronously:

```bash
curl -L "https://api.apify.com/v2/actors/agentx~all-vehicle-scraper/run-sync-get-dataset-items?maxItems=1" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer <APIFY_TOKEN>" \
  -d '{
    "country": "United States",
    "keyword": "Toyota Camry",
    "platforms": ["Cars.com"],
    "max_results": 1
  }'
```

The official [synchronous Actor endpoint](https://docs.apify.com/api/v2/act-run-sync-get-dataset-items-post) documents authentication, timeout, response, and charge-limit options.

#### MCP

Apify documents a hosted Streamable HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=actors,docs"
    }
  }
}
```

After publication, ask the MCP client to find `agentx/all-vehicle-scraper`, inspect the current input schema, run the one-result Toyota Camry scenario, and retrieve the Dataset item. Running Actors requires authentication. See the [Apify MCP guide](https://docs.apify.com/integrations/mcp).

#### Scheduled and workflow runs

Apify schedules, webhooks, Make, n8n, and client SDKs can consume the same input and Dataset after publication. Verify Actor identity in the live integration picker instead of pasting an unverified numeric ID, and keep optional filters absent unless the scheduled workflow intentionally supplies them.

***

### Pricing & Cost Calculator

#### Transparent Pay-Per-Event Pricing

| Event | Price | Billing unit |
| --- | ---: | --- |
| Actor Start | $0.01000 | Charged when the Actor starts. |
| Result - FREE | $0.00850 | One vehicle listing in the default Dataset. |
| Result - BRONZE | $0.00822 | One vehicle listing in the default Dataset. |
| Result - SILVER | $0.00793 | One vehicle listing in the default Dataset. |
| Result - GOLD / PLATINUM / DIAMOND | $0.00765 | One vehicle listing in the default Dataset. |

#### Smallest Useful Run on the FREE Tier

Select one compatible platform and set `max_results` to `1`: one published result × $0.00850 + $0.01000 Actor Start = **$0.01850**. A run with no published result still incurs the Actor Start event. Larger totals depend on the number of records actually published and the applicable tier.

***

### Use Cases & Applications

#### Automotive Market Research

Compare public asking prices, mileage, model years, body types, fuel types, and inventory across supported marketplaces and countries.

#### Dealer Inventory Monitoring

Collect comparable listing records for selected makes, models, dealers, regions, or marketplaces and refresh the search on a schedule that fits your workflow.

#### Vehicle Price Comparison

Use normalized price, currency, mileage, year, make, model, and trim fields to prepare pricing tables, dashboards, and internal market reports.

#### Auction and Classified Discovery

Search supported auction, classified, marketplace, and dealer-inventory sources through the same input and Dataset structure.

#### Lead and Seller Research

Use seller names, seller types, listing locations, descriptions, and source URLs when those fields are publicly available on the selected source.

#### AI and Analytics Workflows

Feed consistent vehicle records into spreadsheets, databases, BI dashboards, search indexes, enrichment workflows, and AI-assisted research tools.

***

### FAQ

#### Which inputs are required?

`country`, `keyword`, and `max_results` are required. `platforms` and `location` are optional and do not receive a non-empty default.

#### Can I search one vehicle marketplace only?

Yes. Set `platforms` to one supported label. Leave it empty to search all compatible sources for the selected country and location.

#### Does `max_results` apply to the whole run?

`max_results` is the maximum number of published vehicle listings per selected platform. A multi-platform run can therefore publish more than that value in total.

#### How does location filtering work?

Enter a city, region, postcode, ZIP code, or local area. The Actor uses location only with sources that can apply it to their search. If no selected source can use the supplied location, the input is rejected instead of silently substituting another place.

#### Why are some output fields empty?

Vehicle marketplaces expose different fields. Optional values remain empty when the source does not publish them; the Actor does not invent missing VINs, prices, mileage, seller details, or vehicle specifications.

#### How can I verify a vehicle record?

Open `source_url`. It points to the original listing used for the published record whenever the source provides a usable listing URL.

#### How is result billing counted?

One `result` event is charged for each vehicle listing written to the default Dataset. A run that publishes no listings still has the Actor Start charge.

#### Is this a vehicle-history or valuation API?

No. All Vehicle Scraper collects public listing information. It does not promise accident history, ownership history, title status, private records, or an independent appraisal unless a source listing explicitly includes that information in a documented output field.

***

### Trust & Data Quality

- **Source traceability:** publishable records include a listing URL for verification.
- **Stable output contract:** all selected sources use the same 35-field Dataset schema.
- **Transparent optionality:** fields that are not published by a source can remain empty.
- **User-controlled scope:** country and keyword are required; platform and location filters remain optional.
- **Current documentation:** supported inputs, platforms, output fields, and prices in this README match the project files reviewed on July 21, 2026.

***

### Legal & Compliance

All Vehicle Scraper is intended for lawful collection and analysis of publicly accessible listing information. Users are responsible for complying with applicable laws, marketplace terms, data rights, privacy requirements, and contractual restrictions. Do not use the Actor for unlawful profiling, discrimination, fraud, unauthorized resale, or access to non-public information.

***

### Related Tools

#### Related Data and Lead Actors

- [eBay Seller Leads API](https://apify.com/agentx/ebay-seller-leads-api?fpr=aiagentapi) - Marketplace seller lead records.
- [Google Maps Store Scraper](https://apify.com/agentx/google-maps-store-scraper?fpr=aiagentapi) - Local dealer and business research.
- [All Shopping Scraper](https://apify.com/agentx/all-shopping-scraper?fpr=aiagentapi) - Multi-marketplace product and price data.

#### Enrich Your Dataset

- [All Property Scraper](https://apify.com/agentx/all-property-scraper?fpr=aiagentapi) - Multi-platform property listings.
- [All Jobs Scraper](https://apify.com/agentx/all-jobs-scraper?fpr=aiagentapi) - Multi-platform job listings.
- [All Video Scraper](https://apify.com/agentx/all-video-scraper?fpr=aiagentapi) - Multi-platform video data.

***

### Support & Community

- **Support:** [@AiAgentApi](https://t.me/AiAgentApi)
- **Community:** [@Apify\_Actor](https://t.me/Apify_Actor)
- **Store:** [All Vehicle Scraper](https://apify.com/agentx/all-vehicle-scraper?fpr=aiagentapi) — publication must be rechecked because the URL returned HTTP 404 on July 21, 2026.
- **API:** [All Vehicle Scraper API](https://apify.com/agentx/all-vehicle-scraper/api?fpr=aiagentapi) — publication must be rechecked because the URL returned HTTP 404 on July 21, 2026.

When requesting help, include the selected country, keyword, platform labels, run ID, and a short description of the expected result.

***

**Last Updated:** July 21, 2026

# Actor input Schema

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

Country or region used for platform routing and proxy selection.

## `keyword` (type: `string`):

Required vehicle search phrase. It is sent without adding, removing, translating, or replacing terms.

## `platforms` (type: `array`):

Optional platform allowlist. Leave empty to use all compatible platforms for the selected country and location.

## `location` (type: `string`):

Optional city, region, postal code, ZIP, or local area. Platforms without a native location request are skipped.

## `max_results` (type: `integer`):

Maximum vehicle listings returned per selected platform.

## Actor input object example

```json
{
  "country": "United States",
  "keyword": "Toyota Camry",
  "max_results": 50
}
```

# Actor output Schema

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

Open the overview table for normalized vehicle listings from the selected supported platforms.

# 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 = {
    "country": "United States",
    "keyword": "Toyota Camry",
    "max_results": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentx/all-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 = {
    "country": "United States",
    "keyword": "Toyota Camry",
    "max_results": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("agentx/all-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 '{
  "country": "United States",
  "keyword": "Toyota Camry",
  "max_results": 50
}' |
apify call agentx/all-vehicle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "All Vehicle Scraper",
        "description": "Search 52 country-aware vehicle marketplaces, classifieds, dealer inventories, and auction sources by keyword and optional native location. Export 35 normalized listing fields with source URLs.",
        "version": "1.0",
        "x-build-id": "7dgUMz2JzOC9spHUH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agentx~all-vehicle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agentx-all-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/agentx~all-vehicle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-agentx-all-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/agentx~all-vehicle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-agentx-all-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",
                "required": [
                    "country",
                    "keyword",
                    "max_results"
                ],
                "properties": {
                    "country": {
                        "title": "🌍 Country",
                        "enum": [
                            "Australia",
                            "Brazil",
                            "Canada",
                            "Egypt",
                            "France",
                            "Germany",
                            "Greece",
                            "Hong Kong",
                            "India",
                            "Indonesia",
                            "Italy",
                            "Mainland China",
                            "Malaysia",
                            "Moldova",
                            "Morocco",
                            "Netherlands",
                            "Pakistan",
                            "Philippines",
                            "Poland",
                            "Portugal",
                            "Russia",
                            "Singapore",
                            "Spain",
                            "Turkey",
                            "Ukraine",
                            "United Kingdom",
                            "United States",
                            "Vietnam"
                        ],
                        "type": "string",
                        "description": "Country or region used for platform routing and proxy selection."
                    },
                    "keyword": {
                        "title": "🔍 Keyword",
                        "type": "string",
                        "description": "Required vehicle search phrase. It is sent without adding, removing, translating, or replacing terms."
                    },
                    "platforms": {
                        "title": "🏢 Platforms",
                        "type": "array",
                        "description": "Optional platform allowlist. Leave empty to use all compatible platforms for the selected country and location.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "28car",
                                "999.md",
                                "Arabam",
                                "Auto.it",
                                "Auto.ru",
                                "Autohome",
                                "Automobile.it",
                                "AutoScout24",
                                "AutoTrader.ca",
                                "Auto Trader UK",
                                "Autotrader US",
                                "Avito Morocco",
                                "Avito Russia",
                                "car.gr",
                                "CarDekho",
                                "CARFAX",
                                "CarGurus",
                                "Carlist.my",
                                "CarMax",
                                "Carmudi Philippines",
                                "Cars.com",
                                "CARS24",
                                "carsales",
                                "CarsGuide",
                                "Carvana",
                                "CarWale",
                                "Cho Tot",
                                "Coches.net",
                                "Copart",
                                "Craigslist Cars & Trucks",
                                "Dongchedi",
                                "Drom.ru",
                                "Dubizzle Egypt",
                                "eBay Motors",
                                "Edmunds",
                                "IAA",
                                "Kelley Blue Book",
                                "La Centrale",
                                "Leboncoin",
                                "Marktplaats",
                                "mobile.de",
                                "Motorist.sg",
                                "OLX Pakistan",
                                "OLX Poland",
                                "OLX Ukraine",
                                "Oto",
                                "Otomoto",
                                "sgCarMart",
                                "Standvirtual",
                                "Subito",
                                "TrueCar",
                                "Webmotors"
                            ]
                        }
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Optional city, region, postal code, ZIP, or local area. Platforms without a native location request are skipped."
                    },
                    "max_results": {
                        "title": "📊 Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum vehicle listings returned per selected platform."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
