# VIN Decoder and Vehicle Recalls

> Bulk VIN decoder for up to 500 VINs per run with official NHTSA data. Get make, model, year, engine and plant, plus recall campaigns.

URL: https://cliqtomedia.com/actors/vin-decoder-vehicle-recalls/

Category: Government & open data · Status: live on Apify Store · Apify page: https://apify.com/cliqtomedia/vin-decoder-vehicle-recalls?fpr=cliqto

Turn a list of VINs into clean vehicle rows with NHTSA data. Each VIN gets a clear status, so typos are easy to spot. Recall campaigns come in a second table.

## How to use it: 3 steps

1. **Make a free Apify account.** Apify is the cloud platform where our tools run. The free plan gives you $5 of usage every month, no credit card needed. You pay Apify, not us.
2. **Paste your input and press Start.** No code needed: you fill in a form (the input). It already has a working example. For example: `1HGCM82633A004352` in VINs. Each start is one run.
3. **Download the results.** When the run ends, the results are in a table (the dataset). Open Output, press Export and pick Excel or CSV. JSON and the API are there too.

## What it does

VIN Decoder & Vehicle Recalls turns a list of VINs into clean vehicle rows with official NHTSA vPIC data: make, model, model year, trim, body, engine, fuel, drive and assembly plant. For each make, model and year it also lists the NHTSA recall campaigns, with component, summary, consequence, remedy and report date.

- `complete` — vPIC decoded the VIN with no warnings (vPIC error code `0`).
- `partial` — the vehicle is known, but vPIC reported a problem, for example a wrong check digit (code `1`) or an incomplete VIN with `*` (code `6`). The decoded fields are still filled.
- `invalid` — vPIC could not find the make or the model year, or the value is not a VIN. The row says why (`decodeError`, `errorText`) and may have a fix in `suggestedVin`. It costs $0.0001.

### Good for

- Decode a fleet, inventory or lead list of up to 500 VINs in one run.
- Find which NHTSA recall campaigns exist for the models in your list.
- Clean VIN columns: find typos, wrong check digits and values that are not VINs.

### Not a good fit

- This is not a VIN history report: no owners, accidents, title or mileage.
- It does not tell you whether a recall applies to one exact VIN, or whether the repair was done. Recalls are listed for the make, model and year. Check one VIN at nhtsa.gov/recalls or with the manufacturer.
- vPIC covers vehicles sold in the United States. Other VINs may come back `partial` or `invalid`.

## Price

Pay per event. Apify bills you, not us.

| What you pay for | Price | When |
|---|---|---|
| Start fee | $0.002 | Charged once per run. This tool uses 1 GB of memory or less by default; more memory costs more. |
| Vehicle decoded | $0.0014 (from $0.0012 on paid Apify plans) | One VIN decoded with status complete or partial. Rows that failed because NHTSA was unavailable are free. |
| Recall record | $0.0001 | One recall campaign row for a decoded vehicle. |
| Invalid VIN checked | $0.0001 | One value that vPIC could not decode, with the reason and a suggested fix when vPIC has one. |

- One VIN: about $0.0034.
- 1,000 VINs: about $1.40 (2 runs of up to 500).
- Every day 100 VINs, for 30 days: about $4.26 a month.
- 500 VINs once a week (4 runs a month): about $2.81 a month.

Free to try: the Apify free plan gives you $5 of usage every month, no credit card needed.

Prices checked on 24 October 2026. Current price: https://apify.com/cliqtomedia/vin-decoder-vehicle-recalls?fpr=cliqto

## Questions

### Is this a vehicle history report?

No. You get no owners, accidents, title or mileage.

### Does it say if a recall applies to my exact car?

No. Recalls are listed by make, model and year, not by one VIN.

### How many VINs can I decode at once?

Up to 500 VINs per run.

### Do I need an NHTSA key?

No. Both NHTSA APIs are public.

### Does it tell me if the recall repair was done?

No. NHTSA's public recall API does not have repair status per VIN.

### Why are recalls in a separate dataset?

Vehicles and recalls have different columns. Two datasets give two clean tables. Join them by `vin` and `appliesToVins`, or by `make`, `model` and `modelYear`.

### Is the output in my input order?

Rows are written in groups. Sort by `inputIndex` to get your order back.

## Data fields

- `rowType` (string): Always vehicle in this dataset.
- `inputIndex` (integer): Position of the VIN in your input (1-based, after removing duplicates). Sort by it to restore input order.
- `inputVin` (string): The value as you entered it (trimmed, max 40 characters).
- `vin` (string): Normalized VIN (uppercase, spaces and dashes removed). * marks an unknown position.
- `decodeStatus` (string): Complete (vPIC ErrorCode 0), partial (vehicle identified but vPIC reported a problem: incomplete VIN, wrong check digit, missing data), invalid (vPIC could not identify make or model year, or the value is not a VIN), error (vPIC unavailable; the row is free).
- `decodeError` (string): Why the VIN was not decoded (invalid input or source error code), null otherwise.
- `errorCodes` (array): VPIC ErrorCode values, e.g. ["0"] clean, ["1"] check digit, ["6"] incomplete VIN, ["5","14"].
- `errorText` (string): VPIC ErrorText explaining the codes.
- `additionalErrorText` (string): VPIC AdditionalErrorText, e.g. a model-year warning.
- `checkDigitValid` (boolean): Local check of the 9th-position check digit (North American VINs); null for incomplete VINs.
- `make` (string): Make, e.g. HONDA.
- `manufacturer` (string): Manufacturer name from vPIC.
- `model` (string): Model, e.g. Accord.
- `modelYear` (integer): Model year.
- `trim` (string): Trim from vPIC.
- `series` (string): Series from vPIC.
- `bodyClass` (string): Body class, e.g. Sedan/Saloon, Coupe, Pickup.
- `vehicleType` (string): Vehicle type, e.g. PASSENGER CAR, TRUCK, MULTIPURPOSE PASSENGER VEHICLE (MPV).
- `doors` (integer): Number of doors.
- `engineCylinders` (integer): Engine cylinders.
- `displacementL` (number): Engine displacement in litres (1 decimal).
- `engineHp` (number): Engine power in horsepower, when vPIC has it.
- `engineModel` (string): Engine model code.
- `fuelTypePrimary` (string): Primary fuel type, e.g. Gasoline, Electric, Diesel.
- `fuelTypeSecondary` (string): Secondary fuel type (hybrids, flex fuel).
- `electrificationLevel` (string): Electrification level, e.g. BEV (Battery Electric Vehicle), HEV.
- `driveType` (string): Drive type, e.g. AWD, 4WD, FWD.
- `transmissionStyle` (string): Transmission style.
- `gvwr` (string): Gross vehicle weight rating class.
- `plantCity` (string): Assembly plant city.
- `plantState` (string): Assembly plant state or province.
- `plantCountry` (string): Assembly plant country.
- `plantCompanyName` (string): Assembly plant company name.
- `suggestedVin` (string): VPIC suggestion when positions are wrong; ! marks the error positions.
- `possibleValues` (string): VPIC possible values for the wrong positions, e.g. (5:BFGKRT).
- `recallLookupStatus` (string): Found (recalls listed for this make/model/year), none_reported (in the index, 0 recalls), candidates_found (the decoded model is not in the recall index under this name; recalls are from similar NHTSA model names, see recallModelCandidates), not_in_recall_index (NHTSA has no recalls under this name; this does NOT prove there are none), skipped_incomplete_decode, not_requested, error (Recalls API failed; never shown as 0 recalls).
- `recallLookupError` (string): Why the recall lookup failed or was skipped by a source error, null otherwise.
- `recallCount` (integer): Number of distinct recall campaigns listed for this make/model/year (or its candidate models); null when not looked up, failed or not in the index.
- `recallCampaignNumbers` (array): NHTSA campaign numbers listed for this make/model/year. Not a confirmation that this VIN is affected.
- `recallModelCandidates` (array): NHTSA recall-index model names that may match the decoded model, e.g. SILVERADO 1500 for Silverado.

## Input settings

- `vins` (array, required): Up to 500 vehicle identification numbers, e.g. 1HGCM82633A004352. Spaces, dashes and case are ignored; duplicates are decoded once. A partial VIN is allowed: use * for an unknown position (e.g. 5UXWX7C5*BA) and it is returned as decodeStatus partial. Values that are not VINs come back as invalid rows ($0.0001 each).
- `includeRecalls` (boolean): Look up NHTSA recall campaigns once per unique make/model/year and add them as recall rows. Recalls are listed for the model, not confirmed for each VIN. Default: true.
- `matchCandidateModels` (boolean): When NHTSA's recall index does not know the decoded model name (e.g. vPIC says Silverado, NHTSA lists SILVERADO 1500), look up up to 3 recall-index models that start with the same name and mark those rows matchType candidate_model. Off: such vehicles get recallLookupStatus not_in_recall_index. Default: true.

## Step by step on Apify

1. Open the Input tab.
2. Keep the three example VINs in VINs (`vins`) or paste your own, one per line.
3. Keep Include NHTSA recalls on.
4. Click Start.
5. Open the Output tab. Vehicles has one row per VIN. Recalls has the recall campaigns.

## Use cases

| Task | Input | You get | Key fields |
|---|---|---|---|
| Decode a fleet or dealer inventory | `vins` | Vehicles | `make`, `model`, `modelYear`, `trim`, `bodyClass`, `fuelTypePrimary` |
| See open safety campaigns for the models you own or sell | `vins`, `includeRecalls: true` | Recalls | `nhtsaCampaignNumber`, `component`, `consequence`, `remedy`, `appliesToVins` |
| Clean a VIN column before import | `vins`, `includeRecalls: false` | Vehicles | `decodeStatus`, `checkDigitValid`, `errorCodes`, `suggestedVin` |
| Plan EV or fuel analytics | `vins` | Vehicles | `electrificationLevel`, `fuelTypePrimary`, `engineCylinders`, `displacementL` |

## Tips

- Sort by input index to get your original order back.
- Check the suggested VIN column for possible typo fixes.
- Join vehicles and recalls by VIN, or by make, model and year.

## Limits



- Up to 500 VINs per run. Time depends mostly on the number of unique make/model/year groups: one recall request per group. In our tests 500 VINs of 92 groups finished in about 60 seconds with 256 MB of memory. For more VINs, start several runs.
- The Actor waits at least 0.3 seconds between requests to NHTSA and retries a few times on errors. It stops source work after 240 seconds, keeps the rows it has and ends with status `CAPPED` or `PARTIAL` in `RUN_SUMMARY`.
- NHTSA data can change at any time. Each row has `fetchedAt`.

## Sample result

```json
{
  "rowType": "vehicle",
  "inputIndex": 1,
  "vin": "1HGCM82633A004352",
  "decodeStatus": "complete",
  "errorCodes": ["0"],
  "checkDigitValid": true,
  "make": "HONDA",
  "model": "Accord",
  "modelYear": 2003,
  "trim": "EX-V6",
  "bodyClass": "Coupe",
  "vehicleType": "PASSENGER CAR",
  "engineCylinders": 6,
  "displacementL": 3,
  "engineHp": 240,
  "fuelTypePrimary": "Gasoline",
  "electrificationLevel": null,
  "driveType": null,
  "plantCity": "MARYSVILLE",
  "plantCountry": "UNITED STATES (USA)",
  "recallLookupStatus": "found",
  "recallCount": 24,
  "recallCampaignNumbers": ["19V182000", "19E068000", "19V499000"],
  "note": "Recalls are listed for the make/model/year, not confirmed for this VIN. Check the VIN at https://www.nhtsa.gov/recalls.",
  "provider": "NHTSA vPIC",
  "fetchedAt": "2026-10-11T06:18:26.048Z"
}
```

## Use it from code

Actor ID: `cliqtomedia/vin-decoder-vehicle-recalls`

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("cliqtomedia/vin-decoder-vehicle-recalls").call(run_input={
    "vins": [
        "1HGCM82633A004352",
        "5YJ3E1EA6PF384836",
        "5UXWX7C5*BA"
    ],
    "includeRecalls": True
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

```bash
curl -X POST "https://api.apify.com/v2/acts/cliqtomedia~vin-decoder-vehicle-recalls/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"vins": ["1HGCM82633A004352", "5YJ3E1EA6PF384836", "5UXWX7C5*BA"], "includeRecalls": true}'
```

```python
# pip install langchain-apify
# set APIFY_TOKEN in your environment
from langchain_apify import ApifyActorsTool

tool = ApifyActorsTool("cliqtomedia/vin-decoder-vehicle-recalls")
result = tool.invoke({"run_input": {"vins": ["1HGCM82633A004352", "5YJ3E1EA6PF384836", "5UXWX7C5*BA"], "includeRecalls": True}})
print(result)
```

run-sync waits up to 300 seconds; for longer runs start a run and use a webhook. LlamaIndex and MCP: https://cliqtomedia.com/actors/ai-agents/

## Similar tools

- [EU TED Tenders Scraper & Monitor](https://cliqtomedia.com/actors/eu-ted-tenders-scraper/)
- [UK Bank Holidays & Business Day Calculator](https://cliqtomedia.com/actors/uk-bank-holidays-business-days/)
- [UK Postcode Lookup](https://cliqtomedia.com/actors/gb-postcode-lookup/)
- [USAspending Federal Awards & Recipient Monitor](https://cliqtomedia.com/actors/usaspending-federal-awards-monitor/)
- [FDA Recalls & Enforcement Monitor](https://cliqtomedia.com/actors/fda-recalls-enforcement-monitor/)
- [NASA POWER Historical Weather & Solar Data](https://cliqtomedia.com/actors/nasa-power-climate-data/)