Car API: free make and model data from 18 countries

If you're building anything that asks "what car is it?" (a quote form, a classifieds site, a fleet tool, an insurance flow) you need a list of makes and models that is complete, current and doesn't fall apart the moment someone outside the US uses it.

That's what the VehiclesDB car API is. 15,068 models across 934 makes, reconciled from official vehicle registers and government data in 18 countries, served as plain JSON. You can get a free key in a minute, and if you'd rather not have a key at all, the same data is a free download.

This page shows real responses (not mockups), what the API does and doesn't do, and how it compares to the other car APIs you're probably looking at.

Try it: real make and model calls

Every response below was produced by the API's own code against dataset version 2026.10.3, on October 10, 2026. The attribution block every response carries is trimmed for space.

List a make's models. One request gets you every model of a make, with its kind, body type, a popularity decile (1 means the top 10% most registered) and the first and last year the registers have it on record:

curl https://vehiclesdb.com/api/v1/makes/skoda/models \
  -H "Authorization: Bearer vdb_pk_YOUR_KEY"

{
  "make": { "name": "Škoda", "slug": "skoda" },
  "models": [
    { "name": "100", "slug": "100", "kind": "car", "body_type": "sedan", "popularity_decile": 8,
      "years_on_record": { "first": 1971, "last": 1978 } },
    { "name": "105", "slug": "105", "kind": "car", "body_type": "sedan", "popularity_decile": 8,
      "years_on_record": { "first": 1987, "last": 1989 } },
    { "name": "110", "slug": "110", "kind": "car", "body_type": "hatchback", "popularity_decile": 9,
      "years_on_record": { "first": 1977, "last": 1978 } },
    ...
  ]
}

Yes, that includes the Škoda 105 and 110. A register remembers cars that a new-car catalog forgot, which matters the moment your users own anything older than five years.

Search across everything. Type-ahead for a form:

curl "https://vehiclesdb.com/api/v1/search?q=golf" \
  -H "Authorization: Bearer vdb_pk_YOUR_KEY"

{
  "query": "golf",
  "results": [
    { "name": "Golf", "slug": "golf", "kind": "car",
      "make": { "name": "Volkswagen", "slug": "volkswagen" },
      "body_type": "hatchback", "popularity_decile": 2 },
    { "name": "E-Golf", "slug": "e-golf", "kind": "car",
      "make": { "name": "Volkswagen", "slug": "volkswagen" },
      "body_type": "hatchback", "popularity_decile": 5 },
    ...
  ],
  "count": 3,
  "dataset_version": "2026.10.3"
}

Resolve a messy string. This is the part no static list can do. You send whatever your users or your data feed typed, and you get back a canonical id, a confidence and an audit trail of how we got there:

curl -X POST https://vehiclesdb.com/api/v1/resolve \
  -H "Authorization: Bearer vdb_sk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": "vw golf"}'

{
  "match": {
    "id": "car/volkswagen/golf",
    "name": "Golf",
    "make": { "id": "volkswagen", "name": "Volkswagen" },
    "kind": "car",
    "confidence": 0.97,
    "method": "alias"
  },
  "alternates": [],
  "resolved_via": ["make_alias:vw→volkswagen", "fold:golf→golf"],
  "dataset_version": "2026.10.3"
}

Registry-style strings work the same way: MERCEDES-BENZ | 300 TDT comes back as car/mercedes-benz/300-tdt with confidence 0.97. And when the resolver isn't sure, it says so. bmw 320d (a version of the 3 Series, not a model of its own in the catalog) returns "match": null instead of a guess. An honest "I don't know" is worth more in a data pipeline than a confident wrong answer.

Those ids are stable. When a model gets renamed or merged, the old id stays in former_ids, so an id you stored last year still points somewhere. The Golf record, for instance, carries eight former ids from earlier releases, typo car/volkswagen/colf included.

Vehicle API for six kinds, not just cars

Most car APIs are exactly that: cars. If your form also gets motorcycles, vans or a fleet of trucks, you end up stitching two or three sources together. The registers we build from record every kind of vehicle, so the API does too:

Kind	Models	Makes
Cars	5,541	315
Motorcycles	6,033	266
Mopeds	1,399	315
Vans	739	130
Trucks	947	95
Buses	409	94

Pass kind=motorcycle (or any of the six) to /api/v1/makes and the list narrows. Honda, for example, comes back with "kinds": ["car", "motorcycle", "moped", "van"] and 1,143 models.

Where the data comes from

Every model in the catalog comes from official government vehicle data in 18 countries: the national registration registers of Argentina, Australia, Finland, Germany, Ireland, Israel, Luxembourg, Malaysia, the Netherlands, New Zealand, Norway, Spain, Thailand, Ukraine and the United Kingdom, the vehicle register of the Swiss canton of Thurgau, plus the official fuel economy listings of the United States (fueleconomy.gov) and Canada (Natural Resources Canada). A model only ships when at least two independent official sources agree it exists (or one source shows a fleet count no typo could produce).

That's also why each record knows where a model is actually on the road. The Volkswagen Golf has register evidence in 17 of the 18 countries; filter /api/v1/makes?country=de and you only get makes Germany has registered. We publish our measured error rate, which is not something you'll see on many car API landing pages.

Automotive API or VIN decoder? What this one does

"Automotive API" means very different things depending on who's searching, so here's the plain version of what you get and what you don't:

What it does today

Makes and models for six vehicle kinds, with body types, aliases and per-country availability
Popularity from real registration counts (deciles and ranks, not opinions)
Resolving messy strings to canonical ids (POST /api/v1/resolve)
An enriched record per model with production runs and variants on paid plans (/api/v1/vehicles/:kind/:make/:model/full)
Vehicle images, make logos, and license plate format validation for 124 jurisdictions

What it doesn't do (yet)

VIN decoding. We don't decode VINs. For US vehicles, the free NHTSA vPIC API does that well, and you can resolve what it returns to our ids.
Trims, engines and full specs per year. CarAPI and other spec providers sell that.
Prices, valuations, vehicle history or listings. Different data, different vendors.

If what you need is "a clean, complete make and model list behind a dropdown or a data pipeline", you're in the right place. If you need a VIN decoded into a trim and an MSRP, you're not, and it's better you know that now.

Free tier, then flat pricing

There are two kinds of key, and the difference matters:

A public key (vdb_pk_…) is made to sit in your page source. It only reaches the dropdown endpoints (makes, models, search, logos, the whole catalog) and those cost 0 credits. You can lock it to your own domains: a domain covers its www. form, and any other subdomain needs its own entry or *.example.com. This is what the make and model dropdown runs on.
A private key (vdb_sk_…) stays on your server and spends credits: 1 per resolve, image or plate match, 2 per enriched record, 5 for a jurisdiction's whole plate format corpus (GET /api/v1/plates/:code).

Every account starts with 100 free credits, once, with no card. After that, plans are flat monthly prices with the calls included: Developer is $49/month for 50,000 credits, Business $299/month for 500,000, Scale $999/month for 2,000,000. No per-call data fees on top. If your credits run out, the API answers 402 and tells you your options; there's no surprise overage bill. The details live on the pricing page.

How it compares to vPIC, CarAPI and Edmunds

These are the names that come up when developers ask for a car API, so here's an honest side by side:

	VehiclesDB	NHTSA vPIC	CarAPI	Edmunds API
Coverage	18 countries' registers	US market	US market	Partner and dealer program only
Vehicle kinds	Cars, motorcycles, mopeds, vans, trucks, buses	Vehicle types incl. motorcycles, trucks	Cars (powersports sold separately)	n/a
VIN decoding	No	Yes, free	Yes (US)	n/a
Years, trims, specs	Years on record free, production runs on paid plans	Model years	Yes, years from 1900, trims and specs from 1990	n/a
Messy-string resolver	Yes	No	No	n/a
Open data download	Yes, CC-BY 4.0	Yes (standalone database)	Free sample set; full feed paid	n/a
Price	Free key, then from $49/month	Free	From $199/year ($299/year with trims and VIN)	n/a

The short version: vPIC is the right tool when you have a US VIN. CarAPI is a good, cheap choice if you need US trims and specs. VehiclesDB is the one to pick when your users aren't only American, when you need motorcycles or trucks from the same source, or when your real problem is a column of messy vehicle names you need to clean. If you landed here because an old Edmunds tutorial stopped working, here's what replaces it, and there's a longer comparison of vehicle data providers too.

SDKs: Ruby, JavaScript and MCP

You don't need an SDK to call a JSON API, but a few shortcuts exist:

Ruby: gem "vehicles" ships the whole open dataset inside the gem, offline, with dropdown helpers and validators. No key, no network.
JavaScript: the make-model-dropdown package gives you a dependent make and model picker with one script tag.
MCP: the gem bundles an MCP server (vehicles-mcp), so an AI agent can query the catalog directly.
Everything else (Python, Go, PHP…): plain HTTP. The full contract, every parameter and error, is in the interactive API reference, generated from the same code that serves the requests.

Get started in five minutes

Create a free account and mint a key under Settings → API keys.
Check it with GET /api/v1/me (that call is free, so nobody pays to find out whether their key works).
Make your first call with one of the examples above.

The getting started guide walks through it step by step. And if you'd rather browse before you build, the whole catalog is on the site: start at the list of makes or the cars, motorcycles and trucks hubs.