# NHTSA Vehicle Recalls & Complaints Scraper (`parseforge/nhtsa-vehicle-recalls-scraper`) Actor

Scrape vehicle recall and complaint data from the National Highway Traffic Safety Administration (NHTSA). Search by make, model, and year. Get recall campaigns, hazard descriptions, remedies, and consumer complaints including crash, fire, injury, and death reports.

- **URL**: https://apify.com/parseforge/nhtsa-vehicle-recalls-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🚗 NHTSA Vehicle Recalls & Complaints Scraper

Whether you're a consumer checking a vehicle's safety history, an automotive researcher tracking recall trends, or a fleet manager monitoring safety issues, this tool makes it easy to collect structured data from the National Highway Traffic Safety Administration.

> **The NHTSA Scraper collects vehicle recalls and safety complaints with campaign numbers, components, summaries, remedies, crash data, injury counts, and more. Filter by make, model, and year.**

### ✨ What Does It Do

- 🔔 **Recall data** - collect campaign numbers, affected components, summaries, consequences, and remedies from NHTSA
- 🚨 **Complaint data** - extract ODI numbers, crash/fire flags, injury and death counts, incident details
- 🚗 **Vehicle filtering** - search by make, model, and model year for targeted results
- 📋 **Multi-model search** - leave model empty to automatically search all models for a given make
- 📊 **Structured output** - get clean JSON, CSV, or Excel data ready for analysis

### 🔧 Input

- **Mode** - choose between Recalls or Complaints
- **Max Items** - how many records to collect (free users get 10 items, paid users up to 1,000,000)
- **Make** - vehicle manufacturer (e.g., "Toyota", "Ford", "Tesla")
- **Model** - vehicle model (e.g., "Camry", "F-150", "Model 3"). Leave empty for all models
- **Model Year** - specific year (e.g., 2024). Leave empty to search recent years

```json
{
    "mode": "recalls",
    "maxItems": 10,
    "make": "Toyota",
    "model": "Camry",
    "modelYear": 2020
}
````

### 📊 Output

#### Recalls

Each recall record includes 12 data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| NHTSACampaignNumber | NHTSA recall campaign number |
| Manufacturer | Vehicle manufacturer name |
| Make | Vehicle make |
| Model | Vehicle model |
| ModelYear | Vehicle model year |
| Component | Affected component |
| Summary | Recall summary description |
| Consequence | Potential consequence of the defect |
| Remedy | Recall remedy description |
| ReportReceivedDate | Date the report was received |
| parkIt | Whether vehicle should be parked immediately |
| overTheAirUpdate | Whether recall can be fixed via OTA update |

```json
{
    "NHTSACampaignNumber": "20V682000",
    "Manufacturer": "Toyota Motor Engineering & Manufacturing",
    "Make": "TOYOTA",
    "Model": "CAMRY",
    "ModelYear": "2020",
    "Component": "FUEL SYSTEM, GASOLINE:DELIVERY:FUEL PUMP",
    "Summary": "Toyota Motor Engineering & Manufacturing (Toyota) is recalling certain 2018-2020 Camry vehicles. The low-pressure fuel pump inside the fuel tank may fail.",
    "Consequence": "If the fuel pump fails, the engine can stall while driving, increasing the risk of a crash.",
    "Remedy": "Toyota will notify owners, and dealers will replace the fuel pump assembly with an improved one, free of charge.",
    "ReportReceivedDate": "04/11/2020",
    "parkIt": false,
    "overTheAirUpdate": false
}
```

#### Complaints

Each complaint record includes 10 data fields.

| Field | Description |
|-------|-------------|
| odiNumber | ODI complaint number |
| manufacturer | Vehicle manufacturer |
| crash | Whether a crash occurred |
| fire | Whether a fire occurred |
| numberOfInjuries | Number of injuries reported |
| numberOfDeaths | Number of deaths reported |
| dateOfIncident | Date the incident occurred |
| dateComplaintFiled | Date the complaint was filed |
| components | Affected components |
| summary | Complaint description |

```json
{
    "odiNumber": 11728272,
    "manufacturer": "Toyota Motor Corporation",
    "crash": false,
    "fire": false,
    "numberOfInjuries": 0,
    "numberOfDeaths": 0,
    "dateOfIncident": "02/01/2024",
    "dateComplaintFiled": "03/31/2026",
    "components": "AIR BAGS",
    "summary": "The contact owns a 2020 Toyota Camry. The contact was notified of NHTSA Campaign Number: 23V865000 (Air Bags); however, the part to do the recall repair was not yet available."
}
```

### 💎 Why Choose the NHTSA Scraper?

| Feature | Our Tool | Manual NHTSA Search |
|---------|----------|---------------------|
| Batch collection | ✅ Up to 1M records | ❌ Browse one at a time |
| Both recalls and complaints | ✅ Single tool | ⚠️ Separate searches |
| Multi-model search | ✅ All models for a make | ❌ One model at a time |
| Structured output | ✅ JSON, CSV, Excel | ❌ HTML pages only |
| Automated scheduling | ✅ Daily/weekly monitoring | ❌ Manual visits |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set the mode (recalls or complaints), vehicle make, model, and year
3. **Run It** - click "Start" and get structured vehicle safety data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🚗 **Car buyers** - check recall history before purchasing a used vehicle
- 🏢 **Fleet managers** - monitor recalls across all vehicles in your fleet
- 📊 **Automotive researchers** - analyze recall trends by manufacturer, component, or year
- ⚖️ **Legal professionals** - gather safety complaint data for automotive litigation
- 🔧 **Repair shops** - stay informed about active recalls for vehicles you service
- 📰 **Journalists** - track safety issues and recall patterns across manufacturers

### ❓ FAQ

🚗 **What is NHTSA?**
The National Highway Traffic Safety Administration is the U.S. federal agency responsible for keeping people safe on roads. They maintain a public database of vehicle recalls and safety complaints.

🔍 **What's the difference between recalls and complaints?**
Recalls are official manufacturer-initiated safety actions to fix defects. Complaints are consumer-reported safety issues filed with NHTSA.

📋 **Do I need to provide all three filters (make, model, year)?**
Only "make" is required. If you leave "model" empty, the scraper will search all models for that make. If you leave "year" empty, it will search the last 10 years.

⏱️ **How long does a run take?**
A single make/model/year query returns results in under 1 second. Broader searches (all models for a make) take a few seconds depending on the number of models.

📅 **How often is NHTSA data updated?**
NHTSA updates their database continuously as new recalls and complaints are filed. Set up a scheduled run to monitor for new safety issues.

### 🔗 Integrate NHTSA Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate vehicle safety monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new recalls match your criteria
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export safety data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| FAA Aircraft Registry Scraper | Extract aircraft registration data | [Link](https://apify.com/parseforge/faa-aircraft-registry-scraper) |
| FINRA BrokerCheck Scraper | Look up broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |
| Copart Public Search Scraper | Scrape vehicle auction listings | [Link](https://apify.com/parseforge/copart-public-search-scraper) |
| AutoNation Scraper | Collect car dealership inventory | [Link](https://apify.com/parseforge/autonation-scraper) |
| Bring A Trailer Auctions Scraper | Gather collector car auction data | [Link](https://apify.com/parseforge/bringatrailer-auctions-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to NHTSA, the U.S. Department of Transportation, or any government agency. It accesses only publicly available data through the official NHTSA public API.

# Actor input Schema

## `mode` (type: `string`):

Choose whether to scrape vehicle recalls or safety complaints.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

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

Vehicle manufacturer (e.g., 'Toyota', 'Ford', 'Tesla', 'Honda', 'BMW'). Leave empty to search all makes.

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

Vehicle model (e.g., 'Camry', 'F-150', 'Model 3', 'Civic'). Leave empty to search all models for the selected make.

## `modelYear` (type: `integer`):

Vehicle model year (e.g., 2024, 2023). Leave empty to search all years.

## Actor input object example

```json
{
  "mode": "recalls",
  "maxItems": 10,
  "make": "Toyota",
  "model": "Camry",
  "modelYear": 2020
}
```

# Actor output Schema

## `recalls` (type: `string`):

Vehicle recall records with campaign numbers, components, and remedies

## `complaints` (type: `string`):

Safety complaint records with crash/fire data and incident details

## `fullData` (type: `string`):

Complete dataset with all scraped fields

# 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 = {
    "mode": "recalls",
    "maxItems": 10,
    "make": "Toyota",
    "model": "Camry",
    "modelYear": 2020
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nhtsa-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 = {
    "mode": "recalls",
    "maxItems": 10,
    "make": "Toyota",
    "model": "Camry",
    "modelYear": 2020,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nhtsa-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 '{
  "mode": "recalls",
  "maxItems": 10,
  "make": "Toyota",
  "model": "Camry",
  "modelYear": 2020
}' |
apify call parseforge/nhtsa-vehicle-recalls-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHTSA Vehicle Recalls & Complaints Scraper",
        "description": "Scrape vehicle recall and complaint data from the National Highway Traffic Safety Administration (NHTSA). Search by make, model, and year. Get recall campaigns, hazard descriptions, remedies, and consumer complaints including crash, fire, injury, and death reports.",
        "version": "1.0",
        "x-build-id": "gc387xdnOa7tRaHDQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nhtsa-vehicle-recalls-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nhtsa-vehicle-recalls-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~nhtsa-vehicle-recalls-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nhtsa-vehicle-recalls-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~nhtsa-vehicle-recalls-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nhtsa-vehicle-recalls-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "recalls",
                            "complaints"
                        ],
                        "type": "string",
                        "description": "Choose whether to scrape vehicle recalls or safety complaints."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Vehicle manufacturer (e.g., 'Toyota', 'Ford', 'Tesla', 'Honda', 'BMW'). Leave empty to search all makes."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Vehicle model (e.g., 'Camry', 'F-150', 'Model 3', 'Civic'). Leave empty to search all models for the selected make."
                    },
                    "modelYear": {
                        "title": "Model Year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Vehicle model year (e.g., 2024, 2023). Leave empty to search all years."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
