# NHTSA Vehicle Recall Crawler - Safety & Recall Data (`jungle_synthesizer/nhtsa-recall-crawler`) Actor

Extract vehicle safety recall records from the NHTSA public API. Query by make, model, and year to get full recall details including NHTSA campaign numbers, components, summaries, consequences, remedies, and safety advisories. No API key required.

- **URL**: https://apify.com/jungle\_synthesizer/nhtsa-recall-crawler.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Recall Crawler

Scrapes vehicle safety recall data from the [NHTSA public API](https://api.nhtsa.gov). Returns full recall records — campaign numbers, components, summaries, consequences, remedies, and safety advisories — for any make, model, and year you specify.

---

### NHTSA Recall Crawler Features

- Queries the official NHTSA recall API — no third-party aggregator, no auth required
- Returns 15 structured fields per recall including campaign number, component, and full text of summary, consequence, and remedy
- Supports multiple vehicle queries in a single run — batch 10 vehicles or 10,000, the actor handles them sequentially
- Flags safety-critical advisories: `park_it`, `park_outside`, and `over_the_air_update` fields surface the serious ones
- Respects `maxItems` across all vehicle queries — useful for testing and cost-capping runs
- Pure API scraping — no browser, no proxy required, no Cloudflare to worry about

---

### What Can You Do With NHTSA Recall Data?

- **Automotive dealers** — Screen used vehicle inventory against open recalls before listing or purchasing
- **Fleet managers** — Run your entire fleet through the API to surface outstanding safety issues before they become insurance claims
- **Insurance underwriters** — Feed recall history into risk models as a vehicle safety signal
- **Consumer apps** — Power a "check your recall status" feature without licensing proprietary data
- **Journalists and researchers** — Track recall patterns by manufacturer, component, or year for investigative reporting
- **Compliance teams** — Monitor manufacturer recall campaigns and remedies for regulatory reporting

---

### How NHTSA Recall Crawler Works

1. You supply a list of vehicles — each with a make, model, and model year.
2. The crawler queries the NHTSA API once per vehicle and collects all matching recalls.
3. Records are transformed into a consistent schema with normalized field names and ISO-formatted dates.
4. Results are saved to the Apify dataset, capped at `maxItems` if you set one.

---

### Input

```json
{
  "vehicles": [
    { "make": "Toyota", "model": "Camry", "modelYear": 2020 },
    { "make": "Ford", "model": "F-150", "modelYear": 2022 }
  ],
  "maxItems": 50
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `vehicles` | array | — | **Required.** List of vehicles to query. Each entry needs `make` (string), `model` (string), and `modelYear` (integer). |
| `maxItems` | integer | 15 | Maximum records to return across all vehicles. Set to `0` for no cap. |
| `proxyConfiguration` | object | `{ useApifyProxy: false }` | Proxy settings. Not needed for the NHTSA API. |

***

### NHTSA Recall Crawler Output Fields

```json
{
  "nhtsa_campaign_number": "20V682000",
  "manufacturer": "Toyota Motor Engineering & Manufacturing",
  "make": "TOYOTA",
  "model": "CAMRY",
  "model_year": 2020,
  "report_received_date": "2020-04-11",
  "component": "FUEL SYSTEM, GASOLINE:DELIVERY:FUEL PUMP",
  "summary": "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.",
  "notes": "Owners may also contact the National Highway Traffic Safety Administration Vehicle Safety Hotline at 1-888-327-4236.",
  "park_it": false,
  "park_outside": false,
  "over_the_air_update": false,
  "url": "https://www.nhtsa.gov/vehicle/recalls#20V682000"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `nhtsa_campaign_number` | string | NHTSA campaign number (e.g., `20V682000`) |
| `manufacturer` | string | Vehicle manufacturer name |
| `make` | string | Vehicle make (e.g., `TOYOTA`) |
| `model` | string | Vehicle model (e.g., `CAMRY`) |
| `model_year` | number | Vehicle model year |
| `report_received_date` | string | Date NHTSA received the recall report (YYYY-MM-DD) |
| `component` | string | Vehicle component involved in the recall |
| `summary` | string | Description of the recall defect |
| `consequence` | string | Potential consequence of the defect |
| `remedy` | string | Remedy/fix for the defect |
| `notes` | string | Additional notes about the recall |
| `park_it` | boolean | Do not drive advisory issued |
| `park_outside` | boolean | Park outside advisory issued (fire risk) |
| `over_the_air_update` | boolean | Recall can be resolved via OTA software update |
| `url` | string | NHTSA recall detail page URL |

***

### FAQ

#### How do I look up recalls for a specific vehicle?

NHTSA Recall Crawler takes a `vehicles` array in your input. Add one object per vehicle with `make`, `model`, and `modelYear`. The actor queries the NHTSA API once per vehicle and returns all matching recalls in a single run.

#### How much does NHTSA Recall Crawler cost to run?

The actor uses pay-per-event pricing at $0.10 per start plus $0.001 per record. A batch of 50 vehicles returning 200 total recalls costs roughly $0.30. That's the price of public data delivered clean.

#### Does NHTSA Recall Crawler need proxies?

It does not. The NHTSA API is a public government service — no IP restrictions, no anti-bot measures. Set `useApifyProxy: false` (the default) and the actor connects directly.

#### What vehicles does NHTSA have recall data for?

NHTSA tracks recalls for vehicles sold in the US going back decades — cars, trucks, motorcycles, trailers, and more. The database covers all manufacturers that have issued safety recalls through the agency.

#### Can I check multiple vehicles in one run?

Yes. The `vehicles` array accepts as many entries as you need. The actor processes them sequentially and applies the global `maxItems` cap across all queries.

***

### Need More Features?

Need recalls by campaign number, date range, or component type? [File an issue](https://console.apify.com/actors/aDZWujJJ3WDYF1YTR/issues) or get in touch.

### Why Use NHTSA Recall Crawler?

- **Official source** — Data comes directly from the NHTSA API, the same database powering the federal government's recall search tool
- **Batch-ready** — Query any number of vehicles in a single run with consistent, structured output for every record
- **Affordable** — $0.001 per record. At that price, checking your entire fleet twice costs less than a cup of coffee

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

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

List of vehicles to look up recalls for. Each entry must include make, model, and modelYear.

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

Maximum number of recall records to return across all vehicles. Set to 0 for all records.

## `proxyConfiguration` (type: `object`):

Select proxies. The NHTSA API is a public government service and does not require proxies.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "vehicles": [
    {
      "make": "Toyota",
      "model": "Camry",
      "modelYear": 2020
    },
    {
      "make": "Ford",
      "model": "F-150",
      "modelYear": 2022
    }
  ],
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "vehicles": [
        {
            "make": "Toyota",
            "model": "Camry",
            "modelYear": 2020
        },
        {
            "make": "Ford",
            "model": "F-150",
            "modelYear": 2022
        }
    ],
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/nhtsa-recall-crawler").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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "vehicles": [
        {
            "make": "Toyota",
            "model": "Camry",
            "modelYear": 2020,
        },
        {
            "make": "Ford",
            "model": "F-150",
            "modelYear": 2022,
        },
    ],
    "maxItems": 15,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/nhtsa-recall-crawler").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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "vehicles": [
    {
      "make": "Toyota",
      "model": "Camry",
      "modelYear": 2020
    },
    {
      "make": "Ford",
      "model": "F-150",
      "modelYear": 2022
    }
  ],
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jungle_synthesizer/nhtsa-recall-crawler --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHTSA Vehicle Recall Crawler - Safety & Recall Data",
        "description": "Extract vehicle safety recall records from the NHTSA public API. Query by make, model, and year to get full recall details including NHTSA campaign numbers, components, summaries, consequences, remedies, and safety advisories. No API key required.",
        "version": "1.0",
        "x-build-id": "8hvgmuTeAYrEUK4MD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~nhtsa-recall-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-nhtsa-recall-crawler",
                "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/jungle_synthesizer~nhtsa-recall-crawler/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-nhtsa-recall-crawler",
                "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/jungle_synthesizer~nhtsa-recall-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-nhtsa-recall-crawler",
                "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": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "vehicles": {
                        "title": "Vehicles to Query",
                        "type": "array",
                        "description": "List of vehicles to look up recalls for. Each entry must include make, model, and modelYear."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "type": "integer",
                        "description": "Maximum number of recall records to return across all vehicles. Set to 0 for all records.",
                        "default": 15
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies. The NHTSA API is a public government service and does not require proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
