# NHTSA Vehicle Complaints Scraper (`parseforge/nhtsa-vehicle-complaints-scraper`) Actor

Unlock public records from Nhtsa Vehicle Complaints with identifiers, dates, parties, descriptions, status flags and direct links to source filings. Designed for compliance, government affairs, due diligence and policy research. Run on demand or on a recurring schedule and feed every row into you.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🚗 NHTSA Vehicle Complaints Scraper

> 🚀 **Pull every consumer vehicle complaint filed with NHTSA in seconds.** Make, model, year, components, crash/fire/injury flags, dates, VIN, and full narratives, straight from the official US safety database.

> 🕒 **Last updated:** 2026-05-27 · **📊 15 fields** per record · **Millions of complaints** · **All US makes and models**

NHTSA collects every consumer complaint filed about a US-registered vehicle and exposes it through a public tabular API. This scraper turns that API into a one-click data pull so you can analyse defect trends, monitor competitor recalls or feed an automotive intelligence pipeline.

Each record covers one ODI complaint, including the manufacturer's name, the component flagged, the incident date, whether it involved a crash, fire, injury or death, the full narrative the consumer submitted, and the affected products list. Pull by make, model and year - the actor handles the rest.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Automotive analysts | Track defect trends by component and model |
| Legal and insurance teams | Source complaint evidence for class-action research |
| OEM safety teams | Monitor competitor complaints for benchmarking |
| Consumer journalists | Investigate emerging vehicle safety issues |
| Data scientists | Train classifiers on complaint narratives |

### 📋 What the NHTSA Vehicle Complaints Scraper does

- Hits the official `api.nhtsa.gov/complaints/complaintsByVehicle` endpoint
- Returns every complaint for a given `make`, `model`, `modelYear`
- Streams structured records: component, narrative, crash/fire/injury flags, dates, VIN
- No API key, no rate-limit headaches, no HTML parsing
- Stream-pull to tabular records

> 💡 **Why it matters:** NHTSA's consumer complaints database is the earliest signal of vehicle defects. Pulling it programmatically means you spot the trend before the recall.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
<tr><td>make</td><td>string</td><td>Vehicle make (Honda, Ford, Tesla)</td></tr>
<tr><td>model</td><td>string</td><td>Vehicle model (Civic, F-150, Model 3)</td></tr>
<tr><td>modelYear</td><td>integer</td><td>Model year (1949-2030)</td></tr>
<tr><td>maxItems</td><td>integer</td><td>Cap on records returned (free plan: 10)</td></tr>
</table>

```tabular
{ "make": "Honda", "model": "Civic", "modelYear": 2020, "maxItems": 25 }
````

```tabular
{ "make": "Tesla", "model": "Model 3", "modelYear": 2023, "maxItems": 100 }
```

> ⚠️ **Good to Know:** NHTSA returns the complete complaint set per (make, model, year) tuple in one response. Loop your runs over multiple years to build a longitudinal dataset.

### 📊 Output

<table>
<tr><th>Field</th><th>Description</th></tr>
<tr><td>🆔 odiNumber</td><td>NHTSA ODI complaint number</td></tr>
<tr><td>🏭 manufacturer</td><td>Reported manufacturer</td></tr>
<tr><td>📅 modelYear / make / model</td><td>Vehicle identification</td></tr>
<tr><td>🔧 components</td><td>Affected component category</td></tr>
<tr><td>💥 crash / 🔥 fire</td><td>Boolean incident flags</td></tr>
<tr><td>🚑 numberOfInjuries / numberOfDeaths</td><td>Counts</td></tr>
<tr><td>🗓 dateOfIncident / dateComplaintFiled</td><td>Dates</td></tr>
<tr><td>📝 summary</td><td>Full complaint narrative</td></tr>
<tr><td>🔢 vin</td><td>Reported VIN if provided</td></tr>
<tr><td>📦 products</td><td>List of affected products</td></tr>
<tr><td>🔗 sourceUrl</td><td>NHTSA public page</td></tr>
<tr><td>🕒 scrapedAt</td><td>ISO timestamp</td></tr>
</table>

### ✨ Why choose this Actor

- 🆓 Public US government data, no auth required
- 📡 Direct hit on the official NHTSA tabular API
- 🧭 Single call returns the entire vehicle complaint set
- 🧰 Clean field names, no HTML parsing
- 📦 Pull as tabular records

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Setup time |
|---|---|---|---|
| Manual tabular open from NHTSA | Free | Bulk only | Hours |
| Direct NHTSA API integration | Free | Full | Code required |
| ParseForge NHTSA Vehicle Complaints Scraper | Pay-per-result | Full + structured | Minutes |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit).
2. Open the NHTSA Vehicle Complaints Scraper.
3. Set `make`, `model`, `modelYear`.
4. Click **Start** and open tabular / spreadsheet / tabular / tabular.
5. Schedule daily, weekly or trigger from Make / Zapier.

### 💼 Business use cases

**Defect monitoring** - alert when complaint volume spikes for a make/model.

**Legal research** - pull every complaint citing a component for a class-action filing.

**OEM benchmarking** - compare your fleet against competitor complaint trends.

**Consumer advisory journalism** - investigate emerging safety issues.

### 🔌 Automating NHTSA Vehicle Complaints Scraper

Hook into Make, Zapier, n8n, Airbyte, Pipedream, Slack, Google Drive, GitHub Actions or any HTTP webhook for scheduled pulls.

### 🌟 Beyond business use cases

- **Research:** model defect propagation across years.
- **Personal:** check the complaint history of a used car before buying.
- **Non-profit:** support consumer protection investigations.
- **Experimentation:** train NLP classifiers on complaint narratives.

### 🤖 Ask an AI assistant about this scraper

Ask ChatGPT, Claude, Perplexity or Copilot: "How do I pull every NHTSA complaint about Tesla Model 3 brakes using the ParseForge Apify actor?"

### ❓ Frequently Asked Questions

**Is NHTSA data public?**
Yes. All consumer complaints are public records under the NHTSA's open data policy.

**How fresh is the data?**
NHTSA updates the complaints database continuously. The actor returns whatever the API serves at run time.

**Can I search by VIN?**
The API filters by make/model/year. Filter the results client-side by VIN.

**Are recalls included?**
This actor focuses on complaints. Recalls are a separate dataset.

**Do I need an API key?**
No. NHTSA is fully open.

**What about commercial vehicles?**
Heavy trucks and buses are indexed under their own makes and models.

**Can I get European or Japanese complaints?**
NHTSA covers the US market. For EU, see EU vehicle safety registries.

**Does the actor decode VINs?**
VINs are returned as-is. Pair with NHTSA's VIN decoder API to enrich.

**How many records per run?**
The API returns the complete set per vehicle, often hundreds.

**Is there pagination?**
The API returns the full set in one call. The actor caps via `maxItems`.

### 🔌 Integrate with any app

Apify, Make, Zapier, n8n, Pipedream, Slack, Airbyte, GitHub, Google Drive, Power Automate, AWS Lambda, REST webhook.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database |
| [OpenAlex Institutions Scraper](https://apify.com/parseforge/openalex-institutions-scraper) | Global research institutions |
| [EU Clinical Trials Register Scraper](https://apify.com/parseforge/eu-clinical-trials-register-scraper) | Clinical trial records |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more US government data scrapers.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with NHTSA. Only publicly available US government data is collected.

# Actor input Schema

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

Vehicle make, e.g. Honda, Ford, Tesla.

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

Vehicle model, e.g. Civic, F-150, Model 3.

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

Vehicle model year (e.g. 2020).

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

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

## Actor input object example

```json
{
  "make": "Honda",
  "model": "Civic",
  "modelYear": 2020,
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nhtsa-vehicle-complaints-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 = { "maxItems": 10 }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHTSA Vehicle Complaints Scraper",
        "description": "Unlock public records from Nhtsa Vehicle Complaints with identifiers, dates, parties, descriptions, status flags and direct links to source filings. Designed for compliance, government affairs, due diligence and policy research. Run on demand or on a recurring schedule and feed every row into you.",
        "version": "0.1",
        "x-build-id": "KqMcTQ4TL4NfE6QyJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nhtsa-vehicle-complaints-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nhtsa-vehicle-complaints-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-complaints-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nhtsa-vehicle-complaints-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-complaints-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nhtsa-vehicle-complaints-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",
                "required": [
                    "make",
                    "model",
                    "modelYear"
                ],
                "properties": {
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Vehicle make, e.g. Honda, Ford, Tesla.",
                        "default": "Honda"
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Vehicle model, e.g. Civic, F-150, Model 3.",
                        "default": "Civic"
                    },
                    "modelYear": {
                        "title": "Model Year",
                        "minimum": 1949,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Vehicle model year (e.g. 2020).",
                        "default": 2020
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```