# NHTSA Vehicle Complaints Scraper (`crawlerbros/cars-com-vehicle-complaints`) Actor

Scrape US vehicle safety complaints and defect investigations from the NHTSA free public API. Search by make, model, model year, or component. No proxy, no auth required.

- **URL**: https://apify.com/crawlerbros/cars-com-vehicle-complaints.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## NHTSA Vehicle Complaints Scraper

Scrape US vehicle complaints, safety products, and recall data from the **NHTSA** (National Highway Traffic Safety Administration) public API. Search complaints by make/model/year, lookup by ODI number, or browse the PICS product catalog. Free public API — no proxy, no auth required.

### What this actor does

- **Four modes:** `complaintsByVehicle`, `complaintsByODI`, `productsByMakeYear`, `productsByModelYear`
- **Complaint data:** full narrative, component, incident date, crash/fire/injury flags
- **PICS catalog:** lists all makes/models with safety-relevant products (complaints, recalls, investigations)
- **Filter by issue type:** complaints (`c`), recalls (`r`), or investigations (`i`)
- **Empty fields are omitted** — no nulls in output

### Output per complaint record

| Field | Description |
|---|---|
| `odiNumber` | NHTSA ODI unique complaint ID |
| `make` | Vehicle make |
| `model` | Vehicle model |
| `modelYear` | Year of manufacture |
| `components` | Affected component(s) |
| `dateOfIncident` | When the incident occurred |
| `dateComplaintFiled` | When the complaint was filed |
| `summary` | Full complaint narrative text |
| `crash` | Whether a crash was involved |
| `fire` | Whether fire was involved |
| `injuriesDeaths` | Whether injuries or fatalities were involved |
| `numberOfDeaths` | Death count |
| `numberOfInjuries` | Injury count |
| `vin` | Vehicle VIN (if provided) |
| `mileage` | Mileage at time of incident |
| `productType` | Vehicle, tire, etc. |
| `recordType` | Always `complaint` or `picsRecord` |
| `sourceUrl` | API URL used to fetch data |
| `scrapedAt` | ISO 8601 timestamp |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `complaintsByVehicle` | `complaintsByVehicle` / `complaintsByODI` / `productsByMakeYear` / `productsByModelYear` |
| `make` | string | `Honda` | Vehicle make (modes: complaintsByVehicle, productsByMakeYear) |
| `model` | string | `Accord` | Vehicle model (mode: complaintsByVehicle) |
| `modelYear` | integer | `2020` | Model year (modes: complaintsByVehicle, productsByMakeYear, productsByModelYear) |
| `odiNumber` | integer | – | ODI number (mode: complaintsByODI) |
| `issueType` | string | `c` | `c` (complaints) / `r` (recalls) / `i` (investigations) |
| `maxItems` | integer | `50` | Maximum records to emit (1–500) |

#### Example: get all complaints for a Honda Accord 2020

```json
{
  "mode": "complaintsByVehicle",
  "make": "Honda",
  "model": "Accord",
  "modelYear": 2020,
  "maxItems": 100
}
````

#### Example: lookup a specific complaint by ODI number

```json
{
  "mode": "complaintsByODI",
  "odiNumber": 11566221
}
```

#### Example: browse products for all makes in a model year

```json
{
  "mode": "productsByModelYear",
  "modelYear": 2022,
  "issueType": "r",
  "maxItems": 200
}
```

### Use cases

- **Vehicle safety research** — find all known complaints for a car before buying
- **Recall monitoring** — track open recalls by make/model/year
- **Insurance analytics** — correlate complaint frequency with risk scoring
- **Automotive journalism** — identify systemic issues across model years
- **Consumer advocacy** — bulk-export complaint data for safety analysis
- **Fleet management** — monitor safety issues for vehicles in your fleet

### FAQ

**What is NHTSA?**
The National Highway Traffic Safety Administration is a US federal agency responsible for vehicle safety. Their public API provides free access to complaints, recalls, safety ratings, and investigations data.

**Is this data real-time?**
Complaints are submitted by consumers and processed by NHTSA. The API reflects the latest publicly released data, typically updated daily.

**Do I need an API key?**
No. The NHTSA API is free and public with no authentication or rate limits beyond standard HTTP behavior.

**What is an ODI number?**
An ODI (Office of Defects Investigation) number is NHTSA's unique identifier for each complaint or recall. Use `mode=complaintsByODI` to fetch a specific complaint.

**What's the difference between complaints, recalls, and investigations?**

- **Complaints (`c`)**: Consumer-reported issues submitted directly to NHTSA
- **Recalls (`r`)**: Official manufacturer or NHTSA-ordered recall campaigns
- **Investigations (`i`)**: Active NHTSA investigations into potential defects

**Why might some fields be missing?**
Not all complaints include VIN, mileage, or injury data — those fields are submitted voluntarily by the consumer. Empty fields are omitted from output.

# Actor input Schema

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

What to fetch.

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

Vehicle manufacturer (e.g. Toyota, Ford, Honda).

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

Vehicle model name (e.g. Civic, Accord).

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

4-digit vehicle model year.

## `odiNumber` (type: `integer`):

NHTSA ODI complaint number to look up.

## `issueType` (type: `string`):

Type of issue to index.

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

Hard cap on emitted records.

## Actor input object example

```json
{
  "mode": "complaintsByVehicle",
  "make": "Honda",
  "model": "Accord",
  "modelYear": 2020,
  "issueType": "c",
  "maxItems": 50
}
```

# Actor output Schema

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

Dataset containing all scraped vehicle complaint records.

# 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": "complaintsByVehicle",
    "make": "Honda",
    "model": "Accord",
    "modelYear": 2020,
    "issueType": "c",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/cars-com-vehicle-complaints").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": "complaintsByVehicle",
    "make": "Honda",
    "model": "Accord",
    "modelYear": 2020,
    "issueType": "c",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/cars-com-vehicle-complaints").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": "complaintsByVehicle",
  "make": "Honda",
  "model": "Accord",
  "modelYear": 2020,
  "issueType": "c",
  "maxItems": 50
}' |
apify call crawlerbros/cars-com-vehicle-complaints --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHTSA Vehicle Complaints Scraper",
        "description": "Scrape US vehicle safety complaints and defect investigations from the NHTSA free public API. Search by make, model, model year, or component. No proxy, no auth required.",
        "version": "1.0",
        "x-build-id": "tePaa8qLes8yb2axJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~cars-com-vehicle-complaints/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-cars-com-vehicle-complaints",
                "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/crawlerbros~cars-com-vehicle-complaints/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-cars-com-vehicle-complaints",
                "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/crawlerbros~cars-com-vehicle-complaints/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-cars-com-vehicle-complaints",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "complaintsByVehicle",
                            "complaintsByODI",
                            "productsByMakeYear",
                            "productsByModelYear"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "complaintsByVehicle"
                    },
                    "make": {
                        "title": "Vehicle make",
                        "type": "string",
                        "description": "Vehicle manufacturer (e.g. Toyota, Ford, Honda).",
                        "default": "Honda"
                    },
                    "model": {
                        "title": "Vehicle model",
                        "type": "string",
                        "description": "Vehicle model name (e.g. Civic, Accord).",
                        "default": "Accord"
                    },
                    "modelYear": {
                        "title": "Model year",
                        "minimum": 1900,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "4-digit vehicle model year.",
                        "default": 2020
                    },
                    "odiNumber": {
                        "title": "ODI number (mode=complaintsByODI)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "NHTSA ODI complaint number to look up."
                    },
                    "issueType": {
                        "title": "Issue type (productsByMakeYear/productsByModelYear)",
                        "enum": [
                            "c",
                            "r",
                            "i"
                        ],
                        "type": "string",
                        "description": "Type of issue to index.",
                        "default": "c"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```