NHTSA VIN Decoder & Recalls Checker

Decode Vehicle Identification Numbers (VINs) and check for NHTSA safety recalls — instantly, at scale, using the official free government API. No API key required.

What This Actor Does

This actor connects to two official U.S. government APIs maintained by the National Highway Traffic Safety Administration (NHTSA):

1. vPIC API (vpic.nhtsa.dot.gov/api) — Decodes a 17-character VIN into full vehicle specifications: make, model, year, trim, engine, transmission, plant location, and more.
2. Recalls API (api.nhtsa.gov/recalls) — Returns all open safety recall campaigns associated with that vehicle's make, model, and year.

Supply a list of VINs, and the actor returns one structured dataset record per VIN containing both decoded specs and associated recall data. Export to JSON, CSV, or Excel.

Who Needs This

• Used car dealers — Instantly vet every trade-in or auction unit for open recalls before purchase.
• Insurance companies — Enrich vehicle records with factory specs for accurate underwriting.
• Fleet managers — Monitor hundreds of vehicles for recall exposure at once.
• Automotive researchers — Build datasets of vehicle specifications from VIN lists.
• Personal car buyers — Check any used vehicle before signing.
• Compliance teams — Document recall status for regulatory audit trails.

Key Benefits

• Free source data — NHTSA APIs are public, no subscription or API key needed.
• Official government data — Same database used by dealers, insurers, and regulators.
• Bulk processing — Decode hundreds of VINs in a single run.
• Recall awareness — Know immediately if a vehicle has open safety campaigns.
• Structured output — Clean JSON/CSV ready for Excel, databases, or downstream tools.
• Low cost — HTTP-only, no browser overhead; runs in 256 MB memory.

Input

VINs to decode

A list of 17-character Vehicle Identification Numbers. You can find a VIN:

• On the driver-side dashboard (visible through the windshield)
• On the driver-side door jamb sticker
• On the vehicle's title or registration
• In an insurance card or loan document

Example VINs for testing:

• 1HGBH41JXMN109186 — Honda Civic
• 5YJSA1DG9DFP14705 — Tesla Model S
• 1FTFW1ET5DKD36530 — Ford F-150
• JN1AZ4EH5FM730841 — Nissan GT-R

includeRecalls (default: true)

When enabled, the actor fetches all NHTSA recall campaigns for each vehicle. Recalls are looked up by make + model + model year (not by individual VIN), so the results represent all known recall campaigns for that vehicle configuration. Disable this option to decode specs only, which is faster and slightly cheaper.

maxRequestRetries (default: 3)

How many times to retry a failed HTTP request before skipping that VIN. The NHTSA APIs are highly reliable — the default of 3 is sufficient for almost all cases.

Output

Each record in the dataset represents one decoded VIN:

Field	Type	Description
vin	string	The input VIN (normalized to uppercase)
make	string	Vehicle manufacturer brand (e.g. "TOYOTA")
model	string	Model name (e.g. "Camry")
modelYear	string	Model year (e.g. "2022")
trim	string	Trim level (e.g. "LE", "Sport")
bodyClass	string	Body style (e.g. "Sedan", "Sport Utility Vehicle")
driveType	string	Drive configuration (e.g. "FWD", "AWD", "RWD")
fuelType	string	Primary fuel type (e.g. "Gasoline", "Electric")
engineCylinders	string	Number of engine cylinders
engineDisplacement	string	Engine displacement in liters
transmissionStyle	string	Transmission type (e.g. "Automatic", "Manual")
plantCountry	string	Country where the vehicle was assembled
plantCity	string	City where the vehicle was assembled
manufacturer	string	Full manufacturer legal name
vehicleType	string	Vehicle category (e.g. "PASSENGER CAR", "TRUCK")
gvwr	string	Gross Vehicle Weight Rating
recalls	array	List of NHTSA recall objects (see below)
recallCount	number	Total number of recalls found
scrapedAt	string	ISO timestamp of when the VIN was decoded
error	string	Only present if the VIN could not be fully decoded

Recall Object Fields

Each item in the recalls array contains:

Field	Type	Description
campaignNumber	string	NHTSA campaign identifier (e.g. "23V123000")
component	string	Vehicle component affected (e.g. "FUEL SYSTEM, GASOLINE")
summary	string	Description of the defect
consequence	string	Safety consequence if unfixed
remedy	string	What the manufacturer will do to fix it

    | `reportDate` | string | Date NHTSA received the recall report |

| parkIt | boolean | NHTSA advises owners to park the vehicle immediately | | parkOutside | boolean | NHTSA advises owners to park outside/away from structures |

Sample Output Record

{
  "vin": "1HGBH41JXMN109186",
  "make": "HONDA",
  "model": "Civic",
  "modelYear": "2021",
  "trim": "LX",
  "bodyClass": "Sedan/Saloon",
  "driveType": "FWD",
  "fuelType": "Gasoline",
  "engineCylinders": "4",
  "engineDisplacement": "1.5",
  "transmissionStyle": "Continuously Variable Transmission (CVT)",
  "plantCountry": "UNITED STATES (USA)",
  "plantCity": "MARYSVILLE",
  "manufacturer": "HONDA OF AMERICA MFG., INC.",
  "vehicleType": "PASSENGER CAR",
  "gvwr": null,
  "recalls": [
    {
      "campaignNumber": "22V800000",
      "component": "ELECTRICAL SYSTEM",
      "summary": "Certain vehicles may have an electrical issue...",
      "consequence": "If the electrical system fails...",
      "remedy": "Honda will notify owners and dealers will...",
      "reportDate": "/Date(1672531200000)/",
      "parkIt": false,
      "parkOutside": false
    }
  ],
  "recallCount": 1,
  "scrapedAt": "2026-03-26T10:00:00.000Z"
}

How to Use

Step 1: Find Your VINs

Collect the 17-character VINs you want to decode. Common sources:

• Vehicle dashboards or door jambs
• Dealer inventory export files (CSV/Excel)
• Insurance company vehicle lists
• DMV records exports

Step 2: Configure the Actor

1. Paste your VINs into the VINs to decode field (one per line).
2. Choose whether to include recall data (default: yes).
3. Click Start.

Step 3: Download Your Data

Once the run completes, use the Export button on the dataset page to download results as:

• JSON — for databases or APIs
• CSV — for Excel or Google Sheets
• XLSX — Excel format directly

Bulk VIN Decoding

The actor processes VINs sequentially, making two API calls per VIN (decode + recalls). A typical run with 100 VINs completes in under 2 minutes. For very large batches (1,000+ VINs), consider breaking input into multiple runs of 500 each.

Understanding the NHTSA API

vPIC (Vehicle Product Information Catalog)

The vPIC database contains vehicle data submitted by manufacturers to NHTSA under federal regulation. It covers virtually all vehicles sold in the United States since the 1980 VIN standardization.

The decode endpoint returns approximately 150+ data fields per VIN. This actor extracts the most useful fields, but the raw response is saved to the Key-Value store as debug-vin-decode for the first VIN if you need to inspect additional fields.

Recalls Database

The NHTSA recalls database is the authoritative record of all safety recall campaigns in the United States. Recalls are issued when a manufacturer or NHTSA determines that a vehicle model has a safety-related defect or does not comply with federal safety standards.

Important note: The NHTSA Recalls API searches by make/model/year, not by individual VIN. This means the actor returns all recall campaigns that apply to your vehicle's configuration. Whether a specific VIN has been remedied at a dealer is not available in this public API — that data requires the manufacturer's internal dealer service records.

Pricing

This actor uses pay-per-event pricing:

• Run start: $0.001 (one-time per run)
• Per VIN decoded: $0.002 (FREE tier) down to $0.0005 (DIAMOND tier)

A batch of 100 VINs costs approximately $0.20 on the FREE tier. Enterprise users with DIAMOND plans pay around $0.05 for the same batch. There are no proxy costs since the NHTSA APIs are public and unauthenticated.

Limitations

• Recall lookup is by vehicle configuration, not by VIN: The recall check uses make + model + year. It does not tell you if that specific vehicle's recall has already been fixed at a dealer.
• US vehicles only: The NHTSA database primarily covers vehicles sold in the United States. VINs for vehicles sold exclusively in other markets may decode with partial information.
• Pre-1980 vehicles: VIN standardization began in 1981. Older vehicles may not decode correctly.
• Invalid VINs: If a VIN has an invalid check digit or is malformed, NHTSA will return a decode with an error code. The actor includes this error in the output record's error field.

Frequently Asked Questions

How do I find a car's VIN?

The VIN is located on:

• The driver's side dashboard (visible through the windshield from outside)
• The driver's side door jamb sticker
• The vehicle title and registration documents
• Insurance cards
• The engine block (for older vehicles)

Why might some fields be null?

NHTSA's vPIC database relies on manufacturer-submitted data. If a manufacturer did not submit certain fields for a specific model year, those fields will be missing. Null fields simply mean NHTSA does not have that data on record.

Why do recalls show for my make/model/year when my car was already fixed?

The NHTSA API returns all recall campaigns ever issued for that vehicle configuration. It does not track whether individual dealerships have completed the repair on specific VINs. To check if your specific VIN has been remedied, use the NHTSA VIN recall lookup tool.

Can I use this for commercial purposes?

Yes. The NHTSA APIs are published as open government data. There are no terms that prohibit commercial use. This actor simply automates calls to the same public endpoints you could call manually.

What happens with an invalid VIN?

The actor still attempts to decode it. NHTSA will return whatever partial information it can, plus an error code and error text. The output record will include an error field explaining the issue.

Is there a rate limit on the NHTSA API?

NHTSA does not publicly document rate limits on their vPIC or Recalls APIs. In practice, the APIs are very permissive for reasonable usage volumes. The actor adds a small delay between requests to be a good API citizen.

Use Cases in Detail

Used Car Dealer Workflow

A dealer receives 50 trade-in VINs from an auction. Instead of manually looking up each one, they paste all 50 VINs into this actor. Within 2 minutes they have a spreadsheet showing year/make/model specs and any open recalls. Vehicles with serious recalls (especially "park it" advisories) can be flagged for priority attention before being listed for sale.

Insurance Underwriting

An insurer processes new policy applications that include VINs. The actor enriches each application with body class, vehicle type, drive configuration, and engine specs — data points used in risk scoring and premium calculation. Running this actor alongside the application pipeline eliminates manual spec lookups.

Fleet Safety Compliance

A fleet operator with 200 company vehicles needs to certify that all vehicles are recall-free for an annual safety audit. They export their vehicle list to VINs, run this actor, and filter for recallCount > 0. All flagged vehicles go on a maintenance schedule.

Research Dataset Building

An automotive data company is building a reference dataset of all Toyota models from 2010–2020. They collect a sample of VINs for each model year and run them through this actor to extract standardized specs from the NHTSA database, building a clean reference table.

Technical Details

• Runtime: Node.js 22
• HTTP library: got-scraping
• Memory: 256 MB (sufficient for any batch size)
• Timeout: 300 seconds (5 minutes)
• Proxy: None required (public government APIs)
• Data source: Official NHTSA vPIC and Recalls APIs

Data Accuracy & Currency

The NHTSA vPIC database is updated regularly by NHTSA as manufacturers submit new vehicle data. However, there may be a lag of several weeks between a vehicle's release and its full appearance in the database. For very new model years (current year or next year), some fields may be missing until NHTSA processes the manufacturer submission.

Recall data is updated in near real time as NHTSA processes new recall campaigns. A recall that was issued this week will typically appear in the API within 1–3 business days.

Related Actors

Looking for more automotive data tools? Check out other actors in the automation-lab store:

• Google Maps Lead Finder — Find automotive businesses by location
• Website Contact Finder — Find contact info for dealer websites