NHTSA VIN Decoder

Decode and validate Vehicle Identification Numbers through the official US National Highway Traffic Safety Administration vPIC API. The NHTSA VIN Decoder returns make, model, model year, trim, body, manufacturer, plant, engine, fuel, transmission, drivetrain, dimensions, weight, safety equipment, decode errors, and the complete set of non-empty source fields for every VIN.

The Actor accepts a batch of VINs, normalizes spaces and hyphens, deduplicates the input, sends bounded concurrent requests to NHTSA, and saves one structured dataset row per response. It requires no account, browser, residential proxy, or external API key.

What can you use it for?

• Validate VIN format and inspect official decode warnings.
• Enrich vehicle inventory with make, model, year, trim, and body data.
• Normalize auction, dealership, insurance, fleet, or marketplace records.
• Add engine, fuel, transmission, drivetrain, and plant attributes.
• Review decoded safety-equipment fields.
• Compare a claimed listing description with public VIN specifications.
• Route decoded vehicles into a CRM, spreadsheet, database, or workflow.
• Create repeatable fleet or auction intake Tasks.

The Actor decodes public manufacturer-submitted VIN characteristics. It does not provide vehicle ownership, title status, accident history, service records, lien information, current mileage, market value, or proof that a listing is legitimate.

Input

{
  "vins": [
    "1HGCM82633A004352",
    "1FTFW1ET5EFA00001"
  ],
  "modelYear": null,
  "maxVins": 10,
  "concurrency": 5
}

Input fields

Field	Type	Default	Description
vins	array	one valid sample VIN	VINs to validate and decode.
modelYear	integer	empty	Optional year hint for partial or ambiguous decoding.
maxVins	integer	10	Maximum unique VINs processed, from 1 to 100.
concurrency	integer	5	Maximum concurrent NHTSA requests, from 1 to 10.

VIN input is uppercased and stripped of spaces and hyphens. The syntax check expects the standard 17-character VIN alphabet and excludes I, O, and Q. A non-standard value can still be submitted to NHTSA so the output contains the official error text and any partial decode information.

modelYear is a hint, not an override. Use it only when NHTSA recommends a year for an incomplete or ambiguous identifier. The decoded model_year remains the source result.

Output

Each dataset item represents one requested VIN.

{
  "vin": "1HGCM82633A004352",
  "requested_vin": "1HGCM82633A004352",
  "is_valid": true,
  "is_valid_format": true,
  "error_code": "0",
  "error_text": "0 - VIN decoded clean. Check Digit (9th position) is correct",
  "additional_error_text": null,
  "make_id": 474,
  "make": "HONDA",
  "model_id": 1861,
  "model": "Accord",
  "model_year": 2003,
  "trim": "EX-V6",
  "series": null,
  "manufacturer": "AMERICAN HONDA MOTOR CO., INC.",
  "vehicle_type": "PASSENGER CAR",
  "body_class": "Coupe",
  "doors": 2,
  "drive_type": "Front-Wheel Drive",
  "plant_city": "MARYSVILLE",
  "plant_state": "OHIO",
  "plant_country": "UNITED STATES (USA)",
  "engine_cylinders": 6,
  "engine_displacement_l": 3,
  "fuel_type_primary": "Gasoline",
  "transmission_style": "Automatic",
  "front_airbag_locations": "1st Row (Driver and Passenger)",
  "seat_belt_type": "Manual",
  "decoded_fields": {
    "VIN": "1HGCM82633A004352",
    "Make": "HONDA",
    "Model": "Accord",
    "ModelYear": "2003"
  },
  "source_api": "NHTSA vPIC DecodeVinValuesExtended",
  "scraped_at": "2026-07-11T12:00:00+00:00"
}

Validation fields

• is_valid_format checks the normalized input against the standard 17-character VIN syntax.
• error_code and error_text are returned by NHTSA.
• is_valid is true only when the syntax check passes and the NHTSA error code is empty or zero.
• suggested_vin preserves a correction suggested by the API when available.

An error does not automatically mean fraud, and a clean decode does not prove ownership, condition, or legal status. Partial, pre-standard, off-road, imported, incomplete, or incorrectly entered identifiers can produce warnings while still returning some useful fields.

Vehicle fields

The normalized top-level fields cover the most reusable attributes:

• identity: make, model, year, trim, series, manufacturer;
• classification: vehicle type, body class, doors, drive type;
• production: plant company, city, state, and country;
• powertrain: cylinders, displacement, engine model, horsepower, fuel, electrification, turbo, transmission;
• dimensions: GVWR class, curb weight, wheelbase, wheels, wheel sizes, seats, and rows;
• safety: airbags, seat belts, ABS, ESC, traction control, TPMS, lane and collision systems;
• source diagnostics: error codes, additional error text, and suggested VIN.

NHTSA does not populate every field for every year, make, or vehicle type. Missing values stay null; the Actor does not infer them from a different model or external database.

Complete source fields

decoded_fields contains every non-empty field in the current NHTSA response, preserving original source names and values. This gives advanced users access to electric-vehicle battery fields, bus and motorcycle fields, detailed safety options, regulatory classifications, and future additions without waiting for the normalized schema to change.

Use top-level fields for stable integrations and decoded_fields for source-complete research. NHTSA can add or rename source fields over time, so downstream systems should tolerate additional keys.

A practical vehicle-enrichment workflow

1. Start with a small batch of VINs from one trusted source.
2. Keep the original identifier alongside the normalized vin.
3. Separate clean decodes from warning and error rows using is_valid and error_code.
4. Compare decoded make, model, year, and body with the source listing.
5. Route mismatches to manual review instead of rejecting them automatically.
6. Retain scraped_at and source_api for traceability.
7. Use recall, title, history, and valuation services separately when those facts are needed.
8. Minimize stored vehicle and customer data to the legitimate purpose.

For marketplace research, join the result to a vehicle listing dataset by VIN. For safety research, pass the decoded make/model/year into a separate NHTSA recalls workflow. Keeping decode and recall Actors separate prevents duplicate result charges and makes each dataset easier to reason about.

Scheduling and integrations

Save a tested input as an Apify Task, then call it from a schedule, webhook, API, or workflow platform. Results can feed:

• Google Sheets or Airtable for reviewed inventory intake;
• n8n, Make, or Zapier for enrichment automation;
• BigQuery, Snowflake, PostgreSQL, or object storage;
• a dealership, auction, fleet, or insurance back office;
• Python or JavaScript through the Apify API.

For event-driven enrichment, run the Task when a new inventory record arrives rather than repeatedly decoding unchanged VINs. VIN characteristics rarely change; cache a successful decode unless the source record or business requirement changes.

Pricing

This Actor uses transparent pay-per-event pricing:

• $0.005 when the Actor starts.
• $0.002 for each VIN decode row saved to the default dataset.

A 100-VIN run costs about $0.205 in Actor charges before ordinary Apify platform usage. Duplicate VIN inputs are processed and billed once. A row with an official decode warning is still a useful result and is billed because it contains validation status and any partial fields. Failed HTTP requests that produce no row are not billed as results.

The price is lower than the closest current competing VIN Decoder Actor's $0.09 start and $0.00299 result price.

Reliability and limits

The engine calls NHTSA's public vPIC API directly with no proxy and no browser. Requests have explicit timeouts, up to three bounded retries, and configurable concurrency capped at ten. Input is capped at 100 VINs per run to keep the public service load predictable. Empty overall output fails explicitly instead of creating a misleading successful run.

Public government APIs can be temporarily slow or unavailable. NHTSA controls the source data, coverage, error messages, and field definitions. Manufacturer submissions can be incomplete. The Actor preserves source values but cannot certify their accuracy for a specific physical vehicle.

Responsible use

Use this Actor for legitimate vehicle validation and enrichment. Follow NHTSA's API guidance, applicable law, and your organization's policies. Do not use a decoded VIN alone to make legal, credit, insurance, employment, or safety decisions. Obtain appropriate title, ownership, history, inspection, and consent records for the intended use.

This Actor is independent and is not affiliated with or endorsed by NHTSA, the US Department of Transportation, or any vehicle manufacturer.

Frequently asked questions

Does it require an NHTSA API key?

No. It uses the public vPIC endpoint.

Can it decode several VINs in one run?

Yes. Submit up to 100 unique VINs and control concurrency from one to ten.

Does a clean result prove the car has a clean title?

No. VIN decoding describes manufacturer and vehicle attributes. It does not provide title, lien, theft, accident, service, or ownership history.

Why are some fields null?

NHTSA coverage varies by model year, manufacturer, and vehicle type. Missing fields are not guessed.

What is decoded_fields?

It is the complete non-empty NHTSA response for that VIN, retained under original source field names.

Can I schedule it?

Yes, but repeated decoding is usually unnecessary. A webhook or intake Task is more efficient for new inventory.

You might also like

• Vehicle Recalls Intelligence for NHTSA recall and complaint research.
• Cars.com Scraper for public US vehicle listings.
• IAAI Vehicle Scraper for public salvage-auction vehicle details.

If the Actor saved time or replaced manual work, leave a Store review. Reviews help prioritize source monitoring, field improvements, and support.

Keywords: VIN decoder API, NHTSA VIN decoder, vehicle specifications API, VIN validation, vPIC API, car make model decoder, vehicle enrichment, engine decoder, VIN safety features, batch VIN lookup.