# Vehicle Recalls & VIN Decoder API - Car Specs, NHTSA (`martin10291/vehicle-recalls-vin-decoder`) Actor

No API key, no login. Decode up to 50 VINs per call with NHTSA vPIC and attach the open NHTSA recalls per vehicle, or look up recalls by year, make and model. Fleet monitor mode returns only new recalls. An NHTSA outage says unavailable, never a false no recalls.

- **URL**: https://apify.com/martin10291/vehicle-recalls-vin-decoder.md
- **Developed by:** [Martin Petrov](https://apify.com/martin10291) (community)
- **Categories:** Automation, Developer tools, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Vehicle Recalls & VIN Decoder API - Car Specs, NHTSA

**Problem:** you run a fleet, a dealership, a marketplace, an insurance or repair workflow and need car specs and open safety recalls for many vehicles. The NHTSA websites check one vehicle at a time, and the raw vPIC answer has about 140 mostly empty fields.

**This API:** up to 50 VINs per call (plus up to 20 vehicles by year, make and model), answered from the official NHTSA services in a few seconds. For each vehicle you get a clean row:

- **VIN decode (NHTSA vPIC):** make, model, model year, trim, body class, vehicle type, engine (cylinders, displacement, hp, fuel), drive type, transmission, doors, plant country and city, manufacturer, GVWR, and safety equipment (ABS, ESC, TPMS, airbags, collision warning where NHTSA has data).
- **Check digit:** `checkDigitValid` is computed locally for North American VINs, so typos are caught early.
- **Open recalls (NHTSA Recalls API):** `recallCount` and a `recalls` list with campaign number, component, summary, consequence, remedy, report date (ISO), park-it / park-outside flags, over-the-air flag and the NHTSA link.

### Why it is different

- **An outage is never a false "no recalls".** If NHTSA does not answer, we retry 3 times; if it is still down, the row says `unavailable` with the reason.
- **Malformed VIN = instant answer** (`invalid_format`, checked locally, no upstream call).
- **Clean output:** empty vPIC fields are dropped, numbers are numbers, dates are ISO.
- **Fleet recall monitor:** `onlyNew: true` + `monitorId` returns one row per recall that is new for that Monitor ID. Schedule it daily or weekly.
- Official public data only, no scraping, no personal data.

### Example (API)

```bash
curl -X POST "https://api.apify.com/v2/acts/martin10291~vehicle-recalls-vin-decoder/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"vins": ["1HGCV1F35KA000001", "1FTFW1ET9DFC10312"], "vehicles": ["2021 toyota camry"], "includeRecalls": true}'
```

Output row (trimmed):

```json
{"type": "vehicle", "vin": "1HGCV1F35KA000001", "status": "ok", "checkDigitValid": true,
 "make": "HONDA", "model": "Accord", "modelYear": 2019, "trim": "Sport", "bodyClass": "Sedan/Saloon",
 "engine": {"cylinders": 4, "displacementL": 1.5, "hp": 192, "fuelType": "Gasoline"},
 "plantCountry": "UNITED STATES (USA)", "recallCount": 6,
 "recalls": [{"campaignNumber": "20V314000", "component": "FUEL SYSTEM, GASOLINE:DELIVERY:FUEL PUMP",
   "reportDate": "2020-05-28", "parkIt": false, "url": "https://www.nhtsa.gov/recalls?nhtsaId=20V314000"}],
 "source": "NHTSA vPIC + NHTSA Recalls API (US market vehicles)", "checkedAt": "2026-11-12T10:00:00Z"}
```

### Use from agents (MCP)

Add the Apify MCP server (`https://mcp.apify.com?tools=martin10291/vehicle-recalls-vin-decoder`) to Claude, Cursor or any MCP client and ask: "Decode these VINs and list their open recalls: ...".

### Input

| Field | What it does |
|---|---|
| `vins` | VINs, up to 50 (17 characters, no I, O, Q) |
| `vehicles` | Recalls without a VIN: "2019 honda accord" or {year, make, model}, up to 20 |
| `includeRecalls` | Attach recalls to every vehicle (default on) |
| `onlyNew` / `monitorId` | Return only recalls not seen before for this Monitor ID (fleet monitor) |

### Honest limits

- **Recalls are matched by make, model and model year** (NHTSA's open recalls API), **not by the individual VIN's repair status.** A listed recall means the model year is covered by that campaign; it does not tell you whether this particular car was already repaired.
- **US market data.** vPIC is built for vehicles sold in the US and Canada; many VINs from other markets decode partially or not at all (`not_decoded`).
- Some vPIC fields are empty for a given VIN because NHTSA has no data; they come back as `null`, which does not mean the feature is missing from the car.
- A make with several words (land rover) needs the object form in `vehicles`.
- A make/model that NHTSA does not know returns 0 recalls, the same as a model with no recalls.

### FAQ

**Pricing?** $1 per 1,000 result rows (one row per vehicle, or per new recall in monitor mode).
**Do I need a key?** No. NHTSA data is open.
**Can I check one VIN's repair status?** Not through the open API. Owners can use NHTSA's own VIN lookup page.

# Actor input Schema

## `vins` (type: `array`):

Vehicle identification numbers (17 characters, no letters I, O, Q), up to 50 per run. A malformed VIN returns a row with status invalid_format and is not sent upstream. VINs of US market vehicles decode best.

## `vehicles` (type: `array`):

Optional. Vehicles to check for recalls without a VIN, up to 20 per run. Each entry is a text like 2019 honda accord (year, one-word make, model) or an object {"year": 2019, "make": "land rover", "model": "range rover"} for makes with several words.

## `includeRecalls` (type: `boolean`):

If on, every decoded VIN or vehicle gets its NHTSA recalls attached (recallCount and the recalls list). Turn off to get only the decoded specs. Always on in Only new recalls mode.

## `onlyNew` (type: `boolean`):

Return one row per recall that was not seen before for this Monitor ID (the first run returns all current recalls). Use it on a schedule to watch a fleet or a dealer stock.

## `monitorId` (type: `string`):

Name of the fleet watch list for Only new recalls mode, e.g. my-fleet. Each Monitor ID keeps its own memory.

## Actor input object example

```json
{
  "vins": [
    "1HGCV1F35KA000001",
    "1FTFW1ET9DFC10312"
  ],
  "vehicles": [
    "2019 honda accord",
    {
      "year": 2021,
      "make": "ford",
      "model": "f-150"
    }
  ],
  "includeRecalls": true,
  "onlyNew": false,
  "monitorId": "default"
}
```

# Actor output Schema

## `results` (type: `string`):

One row per vehicle: VIN decode (make, model, year, engine, plant, safety), recall count and the list of NHTSA recalls with campaign number, component, summary, consequence, remedy and date. In Only new recalls mode one row per new recall.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "vins": [
        "1HGCV1F35KA000001",
        "1FTFW1ET9DFC10312"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("martin10291/vehicle-recalls-vin-decoder").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "vins": [
        "1HGCV1F35KA000001",
        "1FTFW1ET9DFC10312",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("martin10291/vehicle-recalls-vin-decoder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "vins": [
    "1HGCV1F35KA000001",
    "1FTFW1ET9DFC10312"
  ]
}' |
apify call martin10291/vehicle-recalls-vin-decoder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,martin10291/vehicle-recalls-vin-decoder"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/eBaV1ucqlheTQwwdw/builds/j75St61WMlINoKgqa/openapi.json