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

{
  "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

{
  "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.

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

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

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:

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:

{
  "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 — 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.