# cars-data.com — Car Specs API (102k+ variants, 19 languages) (`carsdatacom/car-specs-api`) Actor

180 spec types per variant — engine & fuel, performance, EV/hybrid, safety (30 specs), comfort & interior (47), exterior, chassis, dimensions & weights, consumption (WLTP/NEDC). Search, localized specs, filters, compare. Pay-per-event, no API key.

- **URL**: https://apify.com/carsdatacom/car-specs-api.md
- **Developed by:** [CarsDataCom](https://apify.com/carsdatacom) (community)
- **Categories:** Agents, Developer tools
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 searches

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Car Specs API — 102k+ vehicle variants, 19 languages, EV data

The car-specs data source built for AI agents. Search, full localized specs,
side-by-side compare, and structured filters over **102,191 vehicle
variants**, **1,300+ models**, **5,299+ generations**, **180 spec types**,
across **19 languages** (including Arabic, RTL) — from `cars-data.com`.

No other car-specs provider covers this many European generations in this
many languages. This Actor is also auto-exposed as an MCP tool, so it works
directly inside Claude, Cursor, and Windsurf — not just the Apify Store.

### What it does

Pick a `mode` and this Actor calls the matching `cars-data.com` endpoint and
pushes the result to the run's dataset:

| `mode` | What it does | Required input |
|---|---|---|
| `search` | Free-text search by brand/model/generation name | `query` |
| `get_specs` | Full localized specs for one variant — 180 spec types, with confidence + freshness | `variantId` |
| `compare` | Side-by-side specs for 2-4 variants | `variantIds` |
| `filter` | Structured filter: fuel, body, drive, power, price, year, EV | (all optional) |

Every `get_specs`/`compare` result carries a `confidence` score per spec value
and a `last_synced_at` timestamp — so you can be honest about data freshness
instead of presenting stale or uncertain values as fact.

#### What's in the 180 specs

| Category | Specs | Examples |
|---|---|---|
| Interior | 32 | seat material, layout, storage |
| Safety | 30 | ABS, airbags, ADAS, crash rating |
| Exterior | 21 | lights, wheels, roof, body trim |
| Fuel & Engine | 14 | displacement, cylinders, injection |
| Interior Sizes | 12 | headroom, legroom, shoulder room |
| Comfort | 15 | climate control, seats, infotainment |
| Chassis | 11 | suspension, brakes, steering |
| Weights | 9 | kerb weight, payload, towing |
| Exterior Sizes | 7 | length, width, height, wheelbase |
| Performance | 5 | 0-100, top speed, power-to-weight |
| Consumption (WLTP/NEDC) | 7 | combined/city/highway consumption |
| Electric/Hybrid | 3 | battery capacity, range, charging |
| General, Drive, Transmission, Luggage, Service, Costs | 22 | the rest of the 180 |

### Example input — search

```json
{
  "mode": "search",
  "query": "bmw 3 series",
  "locale": "ro",
  "limit": 5
}
````

### Example input — full specs

```json
{
  "mode": "get_specs",
  "variantId": 42164,
  "locale": "de"
}
```

### Example input — compare

```json
{
  "mode": "compare",
  "variantIds": [42164, 42165],
  "locale": "en"
}
```

### Example input — filter (electric, 200+ hp)

```json
{
  "mode": "filter",
  "fuel": "electric",
  "powerMin": 200,
  "limit": 10
}
```

### Pricing

Pay-per-event — no subscription, no rental. You are charged only for
completed runs, per the event triggered by your chosen `mode` (`search`,
`spec-lookup`, `compare`, or `filter`). See this Actor's **Pricing** tab
for exact per-event rates.

### Data & attribution

Data comes from `cars-data.com`'s multilingual vehicle-specs database.
Output is licensed for use within your own application/workflow, not for
resale or reconstruction of the underlying dataset — see
[cars-data.com/api/terms](https://cars-data.com/api/terms).

### Also available as an MCP server

The same read-model backs a remote MCP server at
`https://api.cars-data.com/mcp` — connect it directly in
Claude, ChatGPT connectors, Cursor, or Windsurf.

# Actor input Schema

## `mode` (type: `string`):

search: free-text lookup (e.g. 'bmw 3 series'). get\_specs: full localized specs for one variant\_id. compare: 2-4 variant\_ids side by side. filter: structured filters (fuel/body/power/price/year/EV).

## `locale` (type: `string`):

One of 19 supported languages.

## `query` (type: `string`):

Free text, e.g. 'bmw 3 series' or 'tesla model s'.

## `variantId` (type: `integer`):

A variant\_id from a prior search/filter run.

## `variantIds` (type: `array`):

2-4 variant\_ids, e.g. \[42164, 42165]

## `fuel` (type: `string`):

e.g. petrol, diesel, electric, hybrid

## `body` (type: `string`):

e.g. suv, sedan, hatchback

## `drive` (type: `string`):

Substring match, e.g. 'front', 'rear', 'all'

## `powerMin` (type: `integer`):

Minimum engine power in horsepower.

## `powerMax` (type: `integer`):

Maximum engine power in horsepower.

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

Maximum new-price snapshot in EUR.

## `year` (type: `integer`):

Only variants whose generation covers this model year.

## `ev` (type: `boolean`):

Restrict results to fully electric variants.

## `limit` (type: `integer`):

Maximum number of results to return (1-50).

## Actor input object example

```json
{
  "mode": "search",
  "locale": "en",
  "ev": false,
  "limit": 10
}
```

# 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("carsdatacom/car-specs-api").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("carsdatacom/car-specs-api").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 carsdatacom/car-specs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=carsdatacom/car-specs-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "cars-data.com — Car Specs API (102k+ variants, 19 languages)",
        "description": "180 spec types per variant — engine & fuel, performance, EV/hybrid, safety (30 specs), comfort & interior (47), exterior, chassis, dimensions & weights, consumption (WLTP/NEDC). Search, localized specs, filters, compare. Pay-per-event, no API key.",
        "version": "0.1",
        "x-build-id": "SoN9p3jijzOkHwTp6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/carsdatacom~car-specs-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-carsdatacom-car-specs-api",
                "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/carsdatacom~car-specs-api/runs": {
            "post": {
                "operationId": "runs-sync-carsdatacom-car-specs-api",
                "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/carsdatacom~car-specs-api/run-sync": {
            "post": {
                "operationId": "run-sync-carsdatacom-car-specs-api",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "get_specs",
                            "compare",
                            "filter"
                        ],
                        "type": "string",
                        "description": "search: free-text lookup (e.g. 'bmw 3 series'). get_specs: full localized specs for one variant_id. compare: 2-4 variant_ids side by side. filter: structured filters (fuel/body/power/price/year/EV).",
                        "default": "search"
                    },
                    "locale": {
                        "title": "Locale",
                        "enum": [
                            "en",
                            "ro",
                            "fr",
                            "de",
                            "es",
                            "it",
                            "sr",
                            "hr",
                            "pt",
                            "pl",
                            "cs",
                            "sk",
                            "hu",
                            "no",
                            "sv",
                            "el",
                            "bg",
                            "da",
                            "ar"
                        ],
                        "type": "string",
                        "description": "One of 19 supported languages.",
                        "default": "en"
                    },
                    "query": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free text, e.g. 'bmw 3 series' or 'tesla model s'."
                    },
                    "variantId": {
                        "title": "Variant ID (mode=get_specs)",
                        "type": "integer",
                        "description": "A variant_id from a prior search/filter run."
                    },
                    "variantIds": {
                        "title": "Variant IDs to compare (mode=compare)",
                        "type": "array",
                        "description": "2-4 variant_ids, e.g. [42164, 42165]",
                        "items": {
                            "type": "integer"
                        }
                    },
                    "fuel": {
                        "title": "Fuel type (mode=filter)",
                        "type": "string",
                        "description": "e.g. petrol, diesel, electric, hybrid"
                    },
                    "body": {
                        "title": "Body type slug (mode=filter)",
                        "type": "string",
                        "description": "e.g. suv, sedan, hatchback"
                    },
                    "drive": {
                        "title": "Drive layout (mode=filter)",
                        "type": "string",
                        "description": "Substring match, e.g. 'front', 'rear', 'all'"
                    },
                    "powerMin": {
                        "title": "Min power, hp (mode=filter)",
                        "type": "integer",
                        "description": "Minimum engine power in horsepower."
                    },
                    "powerMax": {
                        "title": "Max power, hp (mode=filter)",
                        "type": "integer",
                        "description": "Maximum engine power in horsepower."
                    },
                    "priceMax": {
                        "title": "Max price, EUR (mode=filter)",
                        "type": "integer",
                        "description": "Maximum new-price snapshot in EUR."
                    },
                    "year": {
                        "title": "Model year (mode=filter)",
                        "type": "integer",
                        "description": "Only variants whose generation covers this model year."
                    },
                    "ev": {
                        "title": "Electric only (mode=filter)",
                        "type": "boolean",
                        "description": "Restrict results to fully electric variants.",
                        "default": false
                    },
                    "limit": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of results to return (1-50).",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
