canonical: https://jentic.com/apis/nhtsa.dot.gov/nhtsa

# Nhtsa Dot Gov NHTSA Vehicle API (vPIC)

Jentic publishes the only available OpenAPI specification for NHTSA Vehicle API (vPIC), keeping it validated and agent-ready. The vPIC (Product Information Catalog Vehicle Listing) API is a free public service from the U.S. National Highway Traffic Safety Administration that decodes 17-character VINs and returns structured information about makes, models, manufacturers, body class, engine, plant, and safety equipment. It also exposes catalogue endpoints to list every make registered in the U.S., every manufacturer associated with a make, every model produced for a given make and year, and every accepted value for each vehicle variable. There is no API key - all 25 endpoints are open to the public and return JSON, XML, or CSV.

## For AI agents

Decode a VIN, look up makes, models, and manufacturers, and pull structured vehicle data from the U.S. NHTSA vPIC catalogue across 25 free public endpoints.

## Scope

Does not handle vehicle recalls, complaints, crash test ratings, or driver licensing - use for vPIC vehicle catalogue and VIN decoding only.

## Capabilities

- Decode a 17-character VIN into make, model, year, body class, engine, and plant through `/DecodeVin/{vin}`
- Run a flat-format VIN decode that returns one row per VIN through `/DecodeVinValues/{vin}`
- Decode up to 50 VINs in one request through POST /DecodeVINValuesBatch
- Look up the World Manufacturer Identifier (the first three VIN digits) through `/DecodeWMI/{wmi}`
- List every vehicle make registered with NHTSA through /GetAllMakes
- Find every model produced by a given make and year through `/GetModelsForMakeYear/make/{make}/modelyear/{year}`
- Enumerate the accepted values for any vehicle variable through `/GetVehicleVariableValuesList/{variable}`

## Use cases

### VIN decoding for vehicle marketplaces

Auto marketplaces, used-car dealers, and insurance underwriters need to convert a raw VIN into structured make, model, year, body class, and safety equipment data. The vPIC API does this for free with no key - a single GET request to `/DecodeVinValues/{vin}` returns one flat row per VIN, ready to insert into a database or surface in a listing UI. Batch mode supports up to 50 VINs per call.

Example prompt: Call GET `/DecodeVinValues/1HGCM82633A004352`?format=json and return the make, model, model year, and body class fields.

### Batch VIN processing for fleet inventories

Fleet operators and rental companies often need to decode hundreds of VINs at once. The /DecodeVINValuesBatch endpoint accepts a semicolon-separated list of up to 50 VINs in the form body and returns one structured row per VIN in a single response, so a fleet of 500 vehicles only needs ten POST requests instead of 500.

Example prompt: POST a list of 30 VINs separated by semicolons to /DecodeVINValuesBatch and write the decoded results to CSV.

### Make and model catalogue browsing

Build a vehicle picker that knows every make and model legally sold in the U.S. /GetAllMakes returns the full registered make list, `/GetMakeForManufacturer/{manufacturer}` narrows it to one OEM, and `/GetModelsForMakeYear/make/{make}/modelyear/{year}` returns each model produced for a given year. Together they power dropdowns and search facets without scraping.

Example prompt: Call GET `/GetModelsForMakeYear/make/honda/modelyear/2024` and list the returned model names.

### AI agent vehicle data enrichment

An AI agent processing a stream of insurance claims or used-car listings can enrich each record with structured vehicle data on the fly. Through Jentic, the agent calls the right vPIC endpoint by intent - VIN decode, make lookup, or variable enumeration - without managing the underlying URL paths. Because vPIC has no auth, no credentials need to be vaulted; the agent just sends the call.

Example prompt: Search Jentic for 'decode a VIN', load the GET `/DecodeVinValues/{vin}` schema, and execute it for VIN 5YJ3E1EA7KF328931.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/DecodeVin/{vin}` | Decode a single VIN into structured fields |
| GET | `/DecodeVinValues/{vin}` | Decode a VIN in flat one-row-per-VIN format |
| POST | `/DecodeVINValuesBatch` | Batch-decode up to 50 VINs in one request |
| GET | `/GetAllMakes` | List every make registered with NHTSA |
| GET | `/GetAllManufacturers` | List every manufacturer registered with NHTSA |
| GET | `/GetModelsForMakeYear/make/{make}/modelyear/{year}` | List every model produced by a make in a given year |
| GET | `/GetVehicleVariableList` | List every vehicle variable available in vPIC |

## Key resources

- **VIN Decoding** — Decode single or batch VINs and World Manufacturer Identifiers
- **Makes** — List all makes, makes for a manufacturer, and makes by vehicle type
- **Manufacturers** — List all manufacturers and look up details by name or ID
- **Models** — Look up models by make, by make ID, by year, and by vehicle type
- **Vehicle Types** — Get the vehicle types associated with a make
- **Other** — Equipment plant codes, vehicle variables, parts lookups, and Canadian specifications

## Why Jentic

- **Setup:** Wiring the NHTSA vPIC API by hand means building requests against its vehicles host (https://vpic.nhtsa.dot.gov/api/vehicles), threading the VIN into the path, and parsing its response formats yourself. Through Jentic you install once, import the NHTSA Vehicle API from the API Directory, and your agent calls it with no key to manage.
- **Permission scoping:** vPIC is a public read-only catalogue, so scope by operation: limit the agent to the calls it needs, such as decoding a VIN or listing makes, and leave out batch decoding or the full variable list unless you add them. You choose the operations it may call.
- **Credential handling:** vPIC needs no credential, so there is nothing to store; any related configuration your Jentic One instance holds stays encrypted and out of the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'decode this VIN' or 'list all makes for a model year', and Jentic returns the matching vPIC operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **OpenAlex API** — OpenAlex enriches scholarly metadata in much the same free, no-key style that vPIC enriches vehicle metadata.
- **Wikimedia API** — Wikimedia provides general reference data that pairs naturally with vPIC's structured vehicle facts.
- **Trove API** — Trove is another free, key-based public-sector data API - useful as a reference for similar government open-data patterns.

## FAQ

### Why is there no official OpenAPI spec for NHTSA Vehicle API (vPIC)?

NHTSA does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call NHTSA Vehicle API (vPIC) via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the NHTSA vPIC API require?

None. vPIC is a free public service with no API key, OAuth, or basic auth - every endpoint, including VIN decoding, is open. Through Jentic, the agent simply executes the call; there is no credential to vault.

### Can I decode multiple VINs in a single request?

Yes. POST /DecodeVINValuesBatch accepts a semicolon-separated list of up to 50 VINs in the form body and returns one structured row per VIN in the response, ideal for fleet, marketplace, and insurance batch jobs.

### What are the rate limits for the NHTSA vPIC API?

NHTSA does not publish hard rate limits in this OpenAPI spec but asks callers to use the batch endpoint for bulk work and to space single-VIN requests sensibly. Aggressive parallel callers may see throttling at the network edge.

### How do I decode a VIN with the vPIC API through Jentic?

Run pip install jentic, then search Jentic for 'decode a VIN'. Load the GET `/DecodeVinValues/{vin}` schema and execute with the 17-character VIN - Jentic returns make, model, year, body class, engine, and plant fields.

### Is the NHTSA vPIC API free?

Yes. vPIC is run by the U.S. Department of Transportation and is free for both commercial and non-commercial use; there is no key registration and no per-call billing.

### Can I limit what my agent is allowed to do with the NHTSA vPIC API?

Yes. Because you run Jentic One yourself, your own rules decide which vPIC operations the agent may call, so you can grant just what a task needs. For a read-only lookup you might allow only GET `/DecodeVinValues/{vin}` and GET /GetAllMakes while leaving out POST /DecodeVINValuesBatch and the full GET /GetVehicleVariableList. The agent can invoke only the operations you have enabled, and nothing else.