# NHTSA Recalls Scraper - Recalls & Complaints API (`maydit/us-vehicle-recalls-scraper`) Actor

NHTSA recalls scraper: pull vehicle recalls AND owner complaints by make, model, and year - or auto-enumerate a whole make. Export clean JSON/CSV. No API key.

- **URL**: https://apify.com/maydit/us-vehicle-recalls-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** News, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## NHTSA Recalls Scraper - Vehicle Recalls & Owner Complaints API

> Pull official U.S. vehicle safety recalls and owner complaints by make, model, and year - or auto-enumerate an entire make - in one run. No API key.

### What it does

This NHTSA recalls scraper turns the official NHTSA data into clean, normalized records you can actually use. Query **car recall data by make, model, and year**, look up a single **NHTSA campaign number**, or run a **whole make** to auto-enumerate every model for that make. It returns both **official safety recalls** and **owner complaints** (ODI) - including crash, fire, injury, and death flags - so you get complete safety coverage without stitching two tools together. Export results as a **vehicle safety recall dataset** in JSON or CSV. No API key, no scraping headaches.

Most NHTSA tools do one thing: recalls *or* complaints, one model at a time. This one does both, and can sweep an entire make automatically.

### Who it's for

- **Car dealers & used-car marketplaces** - flag open recalls across inventory before resale
- **Fleet managers** - track recalls across every make/model you operate
- **Lemon-law attorneys** - pull owner complaint history and injury/crash data for a vehicle line
- **Auto insurers** - factor recall and defect exposure into risk models
- **Automotive researchers & journalists** - build defect and safety datasets
- **Developers** - a clean recalls + complaints data feed without maintaining an NHTSA integration

### What you get / Output

Each record is one recall or one complaint, normalized to a flat schema. Fields returned:

| Field | Description |
|---|---|
| `type` | `recall` or `complaint` |
| `campaignNumber` | NHTSA recall campaign number (recalls) |
| `odiId` | ODI complaint ID (complaints) |
| `make` | Vehicle make |
| `model` | Vehicle model |
| `modelYear` | Model year |
| `manufacturer` | Manufacturer named in the record |
| `component` | Affected component/system |
| `summary` | Description of the recall or complaint |
| `consequence` | Safety consequence of the defect |
| `remedy` | Recall remedy / fix (recalls) |
| `reportDate` | Date the recall or complaint was reported |
| `parkIt` | Flag: do-not-drive advisory (recalls) |
| `parkOutside` | Flag: park-outside fire-risk advisory (recalls) |
| `crash` | Complaint involved a crash |
| `fire` | Complaint involved a fire |
| `injuries` | Number of injuries reported |
| `deaths` | Number of deaths reported |
| `incidentDate` | Date of the reported incident (complaints) |
| `url` | Source URL for the record |

### Input / How to query

Three modes cover how you can pull data:

- **Specific vehicle** - set a make, model, and model year to pull recalls and complaints for one exact vehicle line. Model must match the NHTSA model name (e.g. `Civic`, `F-150`).
- **Whole make** - set a make and model year without a specific model. The Actor auto-discovers and enumerates every model for that make and year, so you don't need to know each model name up front.
- **Campaign lookup** - provide an NHTSA campaign number (e.g. `23V769000`) to pull one specific recall across every vehicle it covers.

Example - a whole-make sweep for a 2022 make:

```json
{
  "make": "Honda",
  "modelYear": 2022
}
```

Example - a single campaign number:

```json
{
  "campaignNumber": "23V769000"
}
```

### Example use cases

- **Used-car dealer recall sweep** - run whole-make mode across the makes on your lot to surface open recalls and do-not-drive (`parkIt`) advisories on inventory before it sells.
- **Lemon-law case build** - pull every complaint for a make/model/year and filter on `crash`, `fire`, `injuries`, and `deaths` to document a defect pattern.
- **Fleet safety monitoring** - schedule runs for each vehicle line you operate and watch for new `campaignNumber` entries.
- **Insurance risk enrichment** - join recall and complaint counts per make/model/year into underwriting models.
- **Research dataset** - export a vehicle recall and complaint dataset to CSV for analysis.

### Recurring use / scheduling

Set the Actor on a **schedule** (daily or weekly) from the Apify console to monitor recalls automatically - ideal for dealers and fleet managers who need to catch new campaigns as they post. Each run outputs to a dataset you can pull via API, webhook, or direct CSV/JSON export.

To dedupe across runs, key on `campaignNumber` (recalls) or `odiId` (complaints) - both are stable NHTSA identifiers, so you can diff new runs against prior ones and act only on newly added records.

### FAQ

#### How do I get NHTSA recall data in bulk?

Use whole-make mode: set a make and model year without a specific model, and the Actor enumerates every model automatically, returning recalls and complaints together. Then export the dataset as CSV or JSON.

#### How to export vehicle recalls by make and model to CSV?

Run the Actor with your make, model, and model year, then export the run dataset directly to CSV or JSON from the Apify console or the dataset API.

#### Is there an API for car recalls and owner complaints?

Yes - this Actor is a recalls + complaints API on top of the official NHTSA data. Call it via the Apify API, get structured JSON back, and skip building and maintaining your own NHTSA integration. No NHTSA API key is required.

#### How can a dealership monitor recalls across its used car inventory?

Schedule whole-make runs for the makes on your lot, dedupe on `campaignNumber`, and watch the `parkIt` and `parkOutside` flags for do-not-drive and park-outside advisories on vehicles you hold.

#### How do I pull all recalls for a whole vehicle make?

Set the make and model year and leave the model unset. The Actor discovers the exact NHTSA model names and fetches recalls and complaints for all of them.

#### Where can lemon law attorneys download NHTSA complaint data?

Query the make, model, and model year and export. Each complaint includes `crash`, `fire`, `injuries`, `deaths`, `summary`, `consequence`, and `incidentDate` for case documentation.

#### How to look up a recall by NHTSA campaign number?

Use campaign lookup mode: provide the `campaignNumber` (e.g. `23V769000`). The Actor returns that recall across every vehicle it covers.

#### What is the best way to scrape NHTSA recalls and complaints without an API key?

This Actor reads the official NHTSA API directly - no key, no auth setup. Provide your query inputs and it returns clean, normalized records for both recalls and complaints.

#### How do fleet managers track vehicle recalls automatically?

Put the Actor on a daily or weekly schedule for each make/model you run, dedupe on `campaignNumber`, and pipe new records to a webhook, sheet, or alert.

#### Can I get injury, crash, and fire counts from NHTSA complaint data?

Yes. Complaint records include `crash`, `fire`, `injuries`, and `deaths` fields drawn from NHTSA owner-submitted complaint (ODI) data.

### Data source & notes

- **Source:** the official **NHTSA API** (National Highway Traffic Safety Administration), covering safety recalls and owner-submitted complaints (ODI). This is public U.S. government safety data - no API key required.
- **Coverage:** U.S. vehicles as recorded by NHTSA. Model names must match NHTSA's exact spelling in specific-vehicle mode; whole-make mode resolves them for you.
- **Complaints vs. recalls:** recalls are official manufacturer/NHTSA campaigns; complaints are owner-submitted reports and reflect individual claims, not verified defects.
- **Field availability:** some fields are specific to one record type - e.g. `remedy`, `parkIt`, and `parkOutside` apply to recalls; `crash`, `fire`, `injuries`, `deaths`, `odiId`, and `incidentDate` apply to complaints.
- **Freshness:** data reflects what NHTSA has published at run time; schedule the Actor to keep a current feed.

### Related actors

Part of a set of US public-records tools that work well together:

- [CPSC Product Recalls Scraper](https://apify.com/maydit/us-product-recalls-scraper) - consumer product recalls
- [FDA Recalls Scraper](https://apify.com/maydit/us-fda-recalls-scraper) - drug, device and food recalls

> Running all three recall sources together (FDA, CPSC and NHTSA) gives near-complete US recall coverage across regulated products.

See all fifteen at [apify.com/maydit](https://apify.com/maydit).

### Found this useful?

If this actor saved you time, a short review on the Apify Store genuinely helps. Reviews are how the next person decides whether a tool is worth trying.

Something broken, missing a field, or a source you want covered? Open an issue on the **Issues** tab and it will get looked at - that is the fastest route to getting it changed.

# Actor input Schema

## `dataType` (type: `string`):

Recalls = official safety recalls. Complaints = owner-submitted complaints (ODI), including crash/fire/injury flags.

## `make` (type: `string`):

Vehicle make, e.g. 'Honda', 'Ford', 'Tesla'. Case-insensitive.

## `model` (type: `string`):

Exact NHTSA model name, e.g. 'Civic', 'F-150 SUPER CREW'. LEAVE EMPTY to automatically cover ALL models of the make for each year — the Actor discovers the exact model names for you.

## `modelYears` (type: `array`):

One or more 4-digit model years, e.g. 2022. Each year is fetched separately.

## `campaignNumber` (type: `string`):

Look up one specific NHTSA recall campaign (e.g. '23V769000') across every vehicle it covers. When set, the other filters are ignored.

## `maxResults` (type: `integer`):

Upper bound on records returned per run.

## Actor input object example

```json
{
  "dataType": "recalls",
  "make": "Honda",
  "modelYears": [
    "2022"
  ],
  "maxResults": 1000
}
```

# 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 = {
    "make": "Honda",
    "modelYears": [
        "2022"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/us-vehicle-recalls-scraper").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 = {
    "make": "Honda",
    "modelYears": ["2022"],
}

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

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

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

```

## CLI example

```bash
echo '{
  "make": "Honda",
  "modelYears": [
    "2022"
  ]
}' |
apify call maydit/us-vehicle-recalls-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maydit/us-vehicle-recalls-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6ky7V2BBZwTeSmA5g/builds/s3bD0G0ewOaPXQajX/openapi.json