Car API Review: VIN Decoder & Vehicle Data for US Cars

What Car API does and who it is for

Car API is a REST API that exposes structured, searchable data about vehicles sold in the United States. Rather than returning unstructured text, every endpoint returns clean, filterable records organized around a clear hierarchy: year → make → model → trim, with additional detail layers for engines, body styles, colors, and mileage. The VIN decoder goes the other direction, starting from a 17-character identifier and resolving it back to specs and matching trims.

The API is a natural fit for automotive marketplaces, dealer inventory platforms, insurance quoting tools, fleet management apps, and any consumer product that needs to let users select or filter by vehicle attributes. The 98% average success rate and 440 ms average latency suggest it is production-ready rather than experimental.

Endpoint walkthrough

All 12 endpoints use GET and follow a consistent design. Most accept a verbose=yes query parameter that embeds parent-level context (year, make, model, trim) directly in each result row, saving you extra round trips. Several endpoints also accept a json field for complex, multi-condition filters using URL-encoded JSON with operators like >, <, >=, <=, in, and others — useful when simple key-value query strings are too limiting.

Vehicle hierarchy endpoints

• GET /api/years — Returns available model years. Supports complex JSON-condition queries, so you can filter years to a specific set of makes (e.g., only years where Scion or Tesla sold vehicles).
• GET /api/makes — Search makes by name and year. The simplest entry point when building a year/make/model selector.
• GET /api/models — Filter by year, make, model name, trim, or make_id. With verbose=yes, the response embeds the parent make so you do not need a separate lookup.
• GET /api/trims — Retrieve trim-level records with optional verbose context. Trims are where most of the differentiating data lives — packages, configurations, and option codes.
• GET /api/trims/{id} — Fetch every data field associated with a single trim. This is the detail endpoint you will call once a user has navigated through year/make/model/trim.

Specification endpoints

• GET /api/bodies — Body style data (sedan, SUV, coupe, etc.) filterable and verbose-capable.
• GET /api/engines — Engine specifications, similarly filterable. Useful for comparison tools or fuel-type filters.
• GET /api/exterior-colors and GET /api/interior-colors — Color data linked to specific trims. Both support verbose mode and JSON-condition queries.
• GET /api/mileages — Mileage data associated with trims; supports verbose and JSON filtering.
• GET /api/vehicle-attributes — Returns all valid options for a given attribute name. This is the right endpoint to call when populating drop-downs dynamically.

VIN decoder

GET /api/vin/{vin} is the standout endpoint for many use cases. Pass a standard 17-character VIN and the response includes a specs property with detailed vehicle specifications and a trims property listing all trims that match the decoded VIN. One important constraint: on the free Basic plan, VIN decoding is limited to vehicles from 2015 onward (the exact cutoff is noted as "for non-paying users, all VINs for 2..." — the description is truncated, but the pattern matches the broader Basic plan restriction of 2015–2020 data).

Pricing breakdown

The Basic plan's 150 requests per day is realistic for exploratory development and proof-of-concept work, but the data restriction to 2015–2020 model years makes it unsuitable for production. Any app that needs to cover vehicles before 2015 or after 2020 must upgrade.

Pro at $9.99/month is marked as the recommended tier. Its 5,000 monthly requests work out to roughly 166 requests per day on average — more than Basic, but still modest. If your app performs several lookups per user session, you will hit this ceiling quickly with even a few hundred active users per month. Ultra's 15,000 monthly requests and 10 req/sec rate limit make it more appropriate for moderate traffic. Mega's 35,000 requests and the lowest overage rate ($0.0050 per extra call) suit higher-volume applications where predictable burst capacity matters.

Overage pricing is worth factoring into your budget estimates. At the Pro tier, 1,000 extra calls beyond the monthly cap cost $10 — effectively doubling your bill. Moving to Ultra or Mega before you expect to hit overages is usually more economical.

Practical use cases

• Dealership inventory systems: Use makes → models → trims to build structured listings with standardized attribute data rather than relying on freeform dealer input.
• Insurance quoting: The VIN decoder is a common entry point — a customer enters their VIN and the app pulls specs and trim details to pre-fill a quote form.
• Vehicle comparison tools: Pull engine and body data for multiple trims and display side-by-side.
• Consumer car-shopping apps: The color endpoints are particularly useful for adding color filtering to search results, which is often a high-engagement filter.
• Fleet management: Year/make/model lookups combined with mileage data support maintenance scheduling and asset tracking.

Limitations and things to check before integrating

Data scope is US-only. If your application needs coverage for vehicles sold in other markets, this API will not serve that need.

Basic plan year restriction is significant. 2015–2020 is a narrow window. If you are building anything consumer-facing, budget for at least the Pro plan from the start to avoid a disruptive migration.

Monthly versus daily request budgets. Basic counts per day; Pro, Ultra, and Mega count per month. This means paid plans have more flexibility around bursty traffic, but Basic will throttle you on any day you exceed 150 calls regardless of your weekly average.

Rate limits apply at the second level on paid plans (5, 10, and 15 req/sec respectively). For most applications this is not a bottleneck, but high-concurrency batch jobs that process many VINs simultaneously should respect these limits.

Documentation is external. The API is documented in OpenAPI, Swagger, and Redoc formats at carapi.app/api. Review the full schema there before integrating — the endpoint descriptions above give a good overview, but field-level details and full filter options are only in the official docs.

Getting started

Car API is available through its marketplace listing and directly at carapi.app. The Basic plan requires no payment details, making the barrier to a first request low. A recommended path: subscribe to Basic, run queries against /api/makes, /api/models, and /api/trims to validate that the data structure matches what your application expects, then decode a few test VINs with /api/vin/{vin}. Once you have confirmed fit, upgrade to Pro or higher before going to production to unlock the full model year range and a usable monthly request budget.