# NHTSA Recalls Scraper (`automation-lab/nhtsa-vehicle-recall-campaigns`) Actor

Export official NHTSA recall campaigns for batches of vehicle make, model, and model-year filters.

- **URL**: https://apify.com/automation-lab/nhtsa-vehicle-recall-campaigns.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Export official **NHTSA recalls** for batches of vehicle make, model, and model-year filters.

The Actor queries the public NHTSA vehicle recall service and returns normalized campaign numbers, manufacturers, affected components, report dates, consequences, remedies, notes, and safety flags. It is designed for repeatable fleet, dealer, insurance, automotive research, and vehicle-safety workflows.

No NHTSA API key, browser, proxy, or VIN is required.

### What can NHTSA Recalls Scraper do?

- Check up to 100 vehicle configurations in one run.
- Export one dataset row per matching vehicle recall campaign.
- Preserve the input vehicle that produced each result.
- Normalize NHTSA report dates to `YYYY-MM-DD`.
- Filter campaigns by NHTSA report-received date.
- Keep only park-it, park-outside, or over-the-air-update campaigns.
- Deduplicate repeated input filters and campaign rows.
- Stop at a user-controlled global result limit.
- Produce structured JSON, CSV, Excel, XML, RSS, or tabular output through Apify datasets.
- Run once, on a schedule, through the API, or from an Apify integration.

### Who is this NHTSA recall lookup for?

#### Fleet safety teams

Run the same vehicle list on a schedule and compare new campaign numbers with the previous dataset.

#### Dealers and service operations

Export campaign, component, consequence, and remedy data for model-year combinations in inventory.

#### Automotive researchers

Build a reproducible campaign-level dataset without copying text from individual web pages.

#### Insurers and risk analysts

Add official safety-recall context to model-year portfolio analysis.

#### Data and automation teams

Send normalized records to a warehouse, spreadsheet, webhook, or internal safety application.

### Why use this Actor?

NHTSA provides structured public data, but a production workflow still needs batch input handling, validation, normalization, filtering, limits, deduplication, dataset exports, scheduling, and integrations.

This Actor packages those steps into one repeatable Apify job. Every result includes both the vehicle returned by NHTSA and the exact input query that produced it, which makes mixed-fleet exports easier to audit.

The Actor uses direct requests to the official NHTSA API. It does not add browser or proxy cost.

### What NHTSA recall data is extracted?

| Field | Meaning |
| --- | --- |
| `campaignNumber` | Official NHTSA campaign identifier |
| `manufacturer` | Manufacturer responsible for the campaign |
| `component` | Affected vehicle system or component |
| `summary` | Defect or noncompliance summary |
| `consequence` | Potential safety consequence |
| `remedy` | Manufacturer remedy or owner action |
| `notes` | Additional NHTSA notes and contact details |
| `reportReceivedDate` | NHTSA report date normalized to `YYYY-MM-DD` |
| `make` | Vehicle make returned by NHTSA |
| `model` | Vehicle model returned by NHTSA |
| `modelYear` | Vehicle model year returned by NHTSA |
| `queryMake` | Make from the input filter |
| `queryModel` | Model from the input filter |
| `queryModelYear` | Model year from the input filter |
| `parkIt` | NHTSA says not to drive until repaired |
| `parkOutside` | NHTSA says to park away from structures |
| `overTheAirUpdate` | Campaign identifies an over-the-air remedy |
| `sourceUrl` | Official NHTSA API URL used for the row |
| `fetchedAt` | UTC timestamp when the response was fetched |

Fields can be `null` when NHTSA does not provide a value.

### How to run an NHTSA recall check

1. Open the Actor in Apify Console.
2. Add one or more vehicle objects under **Vehicles**.
3. Optionally set a report-date range.
4. Optionally enable **Only safety-flagged campaigns**.
5. Choose the maximum number of records.
6. Click **Start**.
7. Open the default dataset to inspect or export results.

A working input is prefilled, so a first-time user can start immediately.

### Input parameters

| Parameter | Type | Required | Default | Description |
| --- | --- | ---: | --- | --- |
| `vehicles` | array | Yes | Honda Accord 2018 and 2019 | Up to 100 make/model/model-year objects |
| `reportReceivedFrom` | string | No | — | Earliest report date, `YYYY-MM-DD` |
| `reportReceivedTo` | string | No | — | Latest report date, `YYYY-MM-DD` |
| `onlySafetyFlagged` | boolean | No | `false` | Keep park-it, park-outside, or OTA campaigns only |
| `maxItems` | integer | No | `1000` | Global output limit from 1 to 10,000 |

Vehicle makes and models are sent to NHTSA as supplied. Use recognizable source names such as `Ford`, `F-150`, `Toyota`, and `Camry`.

### Example input: batch NHTSA recall lookup

```json
{
  "vehicles": [
    {
      "make": "Honda",
      "model": "Accord",
      "modelYear": 2018
    },
    {
      "make": "Honda",
      "model": "Accord",
      "modelYear": 2019
    }
  ],
  "maxItems": 50
}
```

The final implementation returned 12 useful campaign rows for this exact input during local validation on 2026-08-20.

### Example output

```json
{
  "campaignNumber": "20V314000",
  "manufacturer": "Honda (American Honda Motor Co.)",
  "component": "FUEL SYSTEM, GASOLINE:DELIVERY:FUEL PUMP",
  "summary": "The low-pressure fuel pump inside the fuel tank may fail.",
  "consequence": "Fuel pump failure can cause an engine stall, increasing crash risk.",
  "remedy": "Dealers will replace the fuel pump assembly free of charge.",
  "notes": "Owners may contact the NHTSA vehicle safety hotline.",
  "reportReceivedDate": "2020-05-28",
  "make": "HONDA",
  "model": "ACCORD",
  "modelYear": 2018,
  "queryMake": "Honda",
  "queryModel": "Accord",
  "queryModelYear": 2018,
  "parkIt": false,
  "parkOutside": false,
  "overTheAirUpdate": false,
  "sourceUrl": "https://api.nhtsa.gov/recalls/recallsByVehicle?make=Honda&model=Accord&modelYear=2018",
  "fetchedAt": "2026-08-20T06:30:00.000Z"
}
```

The text above is shortened for readability. Dataset rows preserve the full official NHTSA text returned by the source.

### How much does it cost to export NHTSA recall campaigns?

The Actor uses pay-per-event pricing:

- one `start` event per run;
- one `item` event for each campaign saved to the default dataset;
- no charge for empty queries, rejected records, duplicates, or records removed by filters.

The BRONZE price is **$0.004 per start** plus **$0.0032 per saved campaign**. Subscription tiers use distinct decreasing item prices; Apify Console shows the tier active for your account.

At the BRONZE tier, example Actor charges are:

| Saved campaigns | Calculation | Actor charge |
| ---: | --- | ---: |
| 1 | `$0.004 + 1 × $0.0032` | `$0.0072` |
| 10 | `$0.004 + 10 × $0.0032` | `$0.0360` |
| 100 | `$0.004 + 100 × $0.0032` | `$0.3240` |

Apify platform usage may be billed according to the plan and pricing configuration shown in Console. The Actor makes no proxy requests.

### Date and safety filtering

`reportReceivedFrom` and `reportReceivedTo` are inclusive. A campaign with a missing or invalid NHTSA report date is excluded when either date filter is active.

When `onlySafetyFlagged` is `true`, a row is kept if at least one of these values is true:

- `parkIt`;
- `parkOutside`;
- `overTheAirUpdate`.

A false flag does not mean a recall is unimportant. It only means that NHTSA did not mark that specific operational instruction in the API response.

### Batch fleet monitoring workflow

A practical recurring workflow is:

1. Store the fleet's distinct make/model/model-year combinations in Actor input.
2. Set `reportReceivedFrom` to the start of the monitoring period.
3. Schedule the Actor daily or weekly.
4. Export `campaignNumber` plus the three `query*` fields.
5. Compare campaign numbers with the previous run.
6. Notify the responsible safety or service team about additions.
7. Retain `sourceUrl` for audit and review.

The Actor exports current source responses. It does not maintain historical snapshots or send alerts by itself; Apify schedules, webhooks, and downstream systems provide those workflow steps.

### Export and integration options

The default dataset can be downloaded as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

Common integrations include:

- Google Sheets for a safety review queue;
- Slack or email through an Apify webhook automation;
- Make, Zapier, or n8n for routing new campaigns;
- BigQuery, Snowflake, PostgreSQL, or object storage;
- a dealer inventory or fleet-maintenance application;
- an internal risk dashboard.

Use `campaignNumber` together with `queryMake`, `queryModel`, and `queryModelYear` as a practical downstream comparison key.

### Run through the Apify API with cURL

Set `APIFY_TOKEN` in your environment rather than placing a token in source code.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~nhtsa-vehicle-recall-campaigns/runs?waitForFinish=300" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "vehicles": [
      {"make": "Ford", "model": "F-150", "modelYear": 2021}
    ],
    "maxItems": 50
  }'
```

Read dataset items from the `defaultDatasetId` returned by the run.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor(
  'automation-lab/nhtsa-vehicle-recall-campaigns'
).call({
  vehicles: [
    { make: 'Ford', model: 'F-150', modelYear: 2021 },
  ],
  maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor(
    "automation-lab/nhtsa-vehicle-recall-campaigns"
).call(run_input={
    "vehicles": [
        {"make": "Toyota", "model": "Camry", "modelYear": 2020}
    ],
    "maxItems": 50,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### Use the Actor through MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/nhtsa-vehicle-recall-campaigns"
```

#### Claude Desktop

Add this server to Claude Desktop's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/nhtsa-vehicle-recall-campaigns"
    }
  }
}
```

#### Cursor

Add the same `mcpServers.apify.url` entry in Cursor's MCP settings, then enable the server for the workspace.

#### VS Code

Add the HTTP endpoint as an MCP server in VS Code's MCP configuration and start it from the MCP servers panel.

Example prompts:

- "Check official NHTSA recalls for 2021 Ford F-150 and return campaign, component, consequence, and remedy."
- "Run a batch recall check for these fleet vehicle model years and summarize any park-it campaigns."
- "Export NHTSA campaigns reported since 2024 for my supplied make/model/year list."

### Limits and source behavior

- The Actor supports make/model/model-year recall lookups, not VIN lookup.
- Input is limited to 100 distinct vehicle filters per run.
- Output is limited to 10,000 rows per run.
- NHTSA can return no campaigns for a valid vehicle combination.
- Unknown combinations can return a structured empty result with HTTP 400; the Actor treats that source shape as a normal empty query.
- NHTSA field availability and wording can change.
- The Actor does not infer whether a specific physical vehicle has received a repair.
- Safety flags are passed through from NHTSA and are not independent safety advice.
- Dates describe when NHTSA received a campaign report, not necessarily when every owner was notified.

### Reliability and error handling

Transient network errors, HTTP 408, HTTP 429, and server errors are retried with bounded exponential backoff.

Malformed input fails the run with a non-zero status before data extraction. Deterministic upstream errors are not retried blindly.

If a valid query has no recalls, the run succeeds and saves no rows for that query. A mixed batch can therefore contain results for some vehicles and none for others.

`maxItems` is global across the batch. Vehicle filters are processed in input order, so use separate runs when every vehicle needs an independent guaranteed cap.

### Troubleshooting

#### Why did my run return zero records?

Check the spelling and punctuation used by NHTSA for the make and model. A valid vehicle can also have no campaigns in the source. Remove date and safety filters to distinguish an empty source result from a filtered result.

#### Why is a known campaign missing after adding dates?

The filters use NHTSA's `ReportReceivedDate`. They do not use owner-notification, remedy, manufacture, or publication dates.

#### Why is `parkIt` false for a serious recall?

The flags represent specific NHTSA operational markers. Review `summary`, `consequence`, and `remedy` for the complete campaign context.

#### Can I check a VIN?

No. This Actor intentionally focuses on batch campaign exports by make, model, and model year. It does not claim vehicle-specific repair status.

### Legality and responsible use

The Actor reads public vehicle-safety information from the official U.S. National Highway Traffic Safety Administration API.

Use results for lawful safety, research, compliance, and operational purposes. Respect applicable rules for storage, redistribution, automated decisions, and notices to vehicle owners.

Recall data is informational. Confirm urgent instructions and vehicle-specific applicability with NHTSA, the manufacturer, or an authorized dealer before making safety decisions.

This Actor is not affiliated with or endorsed by NHTSA.

### Frequently asked questions

#### Does the Actor require an NHTSA API key?

No. The supported recall endpoint is public.

#### Does it use a proxy or browser?

No. It sends direct HTTPS requests to the official structured API.

#### Are duplicate vehicle filters charged twice?

No. Identical make/model/model-year inputs are processed once.

#### Are filtered or duplicate rows charged?

No. The `item` event is emitted only for rows accepted into the default dataset.

#### Can I schedule recurring checks?

Yes. Use Apify schedules and compare campaign numbers downstream. The Actor itself does not store history or send alerts.

#### Can I export to a spreadsheet?

Yes. Download CSV or Excel directly from the dataset, or connect the run to a spreadsheet automation.

### Related automation-lab Actors

- [NHTSA Vehicle Complaints Scraper](https://apify.com/automation-lab/nhtsa-vehicle-complaints-scraper) — export consumer complaint records for make, model, and model-year research.

Use complaints for reported owner experiences and this Actor for official recall campaign records. They are different source record types and should not be treated as equivalent.

# Actor input Schema

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

Vehicle combinations to check against the official NHTSA recalls API. Duplicate combinations are processed once. Maximum 100.

## `reportReceivedFrom` (type: `string`):

Optional earliest NHTSA report-received date to include, in YYYY-MM-DD format.

## `reportReceivedTo` (type: `string`):

Optional latest NHTSA report-received date to include, in YYYY-MM-DD format.

## `onlySafetyFlagged` (type: `boolean`):

Keep only campaigns where NHTSA marks park-it, park-outside, or over-the-air-update as true.

## `maxItems` (type: `integer`):

Maximum number of normalized recall records saved across all vehicle filters.

## Actor input object example

```json
{
  "vehicles": [
    {
      "make": "Honda",
      "model": "Accord",
      "modelYear": 2018
    },
    {
      "make": "Honda",
      "model": "Accord",
      "modelYear": 2019
    }
  ],
  "onlySafetyFlagged": false,
  "maxItems": 20
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing normalized NHTSA recall campaign records.

## `overview` (type: `string`):

Table view of campaign identity, affected vehicle, component, report date, and safety flags.

# 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 = {
    "vehicles": [
        {
            "make": "Honda",
            "model": "Accord",
            "modelYear": 2018
        },
        {
            "make": "Honda",
            "model": "Accord",
            "modelYear": 2019
        }
    ],
    "onlySafetyFlagged": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nhtsa-vehicle-recall-campaigns").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 = {
    "vehicles": [
        {
            "make": "Honda",
            "model": "Accord",
            "modelYear": 2018,
        },
        {
            "make": "Honda",
            "model": "Accord",
            "modelYear": 2019,
        },
    ],
    "onlySafetyFlagged": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nhtsa-vehicle-recall-campaigns").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 '{
  "vehicles": [
    {
      "make": "Honda",
      "model": "Accord",
      "modelYear": 2018
    },
    {
      "make": "Honda",
      "model": "Accord",
      "modelYear": 2019
    }
  ],
  "onlySafetyFlagged": false,
  "maxItems": 20
}' |
apify call automation-lab/nhtsa-vehicle-recall-campaigns --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/nhtsa-vehicle-recall-campaigns"
        }
    }
}

```

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/iOKRXYy2dWni9O0zV/builds/e1W1oiS7s3KXfamJ1/openapi.json