# NHTSA Vehicle Safety Scraper — Recalls, Complaints & VIN (`logiover/nhtsa-vehicle-safety-scraper`) Actor Scrape NHTSA vehicle recalls, owner complaints, 5-star safety ratings and VIN decode data by make, model and year. Keyless official US government data. No API key, no login. - **URL**: https://apify.com/logiover/nhtsa-vehicle-safety-scraper.md - **Developed by:** [Logiover](https://apify.com/logiover) (community) - **Categories:** Other - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $1.50 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows. 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Safety Scraper — Recalls, Complaints & VIN Pull official US vehicle-safety data — recalls, consumer complaints, 5-star crash ratings, and full VIN decodes — straight from NHTSA, with no API key and no login. ### What does this scraper do? This scraper collects vehicle-safety data directly from the **National Highway Traffic Safety Administration (NHTSA)**, the US government agency that regulates road safety. It talks to two official open-data engines — `api.nhtsa.gov` (recalls, complaints, and 5-star safety ratings) and `vpic.nhtsa.dot.gov` (VIN decoding) — and returns clean, structured records you can drop straight into a spreadsheet, database, or dashboard. You choose one of four data types, then either list the vehicles you care about as `Make|Model` pairs with a model-year range, or paste in a batch of VINs. Because this is US government open data, there is **no API key, no token, and no login** — you just run it. And it scales: a single run routinely yields hundreds to thousands of records (for example, **340 complaints** for one popular model-year), so you can build a full safety picture across a whole inventory or research set in one pass. ### Who is it for? - **Car dealers & marketplaces** — flag open recalls and safety issues across your inventory before a car hits the lot or a listing goes live. - **Insurers & actuaries** — enrich policies and pricing models with real complaint counts, crash/fire flags, injury/death data, and crash-test ratings. - **Product-liability & lemon-law attorneys** — gather documented complaint and recall evidence tied to a specific make, model, year, or VIN. - **Automotive researchers & journalists** — analyze safety trends by component, manufacturer, or model year with real, citable government data. - **Fleet & safety managers** — monitor the vehicles you operate for "do-not-drive" recalls and emerging defect patterns. ### Use cases - **Recall monitoring for a dealer's inventory** — cross a list of the makes/models you stock against every year in range and surface open recall campaigns, including urgent *park-it* (do-not-drive) alerts. - **Complaint-trend analysis by component** — pull complaints for a model line and group them by component (transmission, electrical, airbags) to spot systemic defects early. - **Safety-rating comparison tables** — build side-by-side 5-star tables (overall, front, side, rollover) to compare competing models for buyers or editorial content. - **VIN enrichment for listings & insurance** — decode VINs in bulk to fill in make, model, trim, engine, drivetrain, and plant details for marketplace listings or policy records. - **Litigation evidence gathering** — assemble complaint ODI numbers, incident dates, injury/death counts, and recall campaign numbers as documented, government-sourced evidence. ### Why use this scraper? - **Keyless official data** — pulls directly from NHTSA's public endpoints. No API key, no login, no rate-limit token juggling. - **Four datasets in one** — recalls, complaints, 5-star safety ratings, and VIN decode, all behind a single `dataType` switch. - **Bulk by make / model / year** — list any number of vehicles and cross each one with every year in your range in a single run. - **Real numbers and booleans** — injury and death counts, crash/fire flags, and do-not-drive / park-outside flags come through as actual integers and booleans, not free text. - **Full VIN decode** — turn a 17-character VIN (or a partial VIN with `*`) into 20+ structured fields including engine, drivetrain, body class, and plant. - **Export anywhere, pay per result** — results export to CSV, JSON, or Excel, and you only pay for the records you actually get. ### What data can you extract? Every record shares a common core — `dataType`, `make`, `model`, `modelYear`, `manufacturer`, `recordId`, `url`, and `scrapedAt` — plus fields specific to the data type you chose. Here is what each type returns. #### Recalls | Field | Type | Description | |---|---|---| | campaignNumber | string | NHTSA recall campaign ID (e.g. `23V070000`) | | component | string | Affected system (e.g. `POWER TRAIN:AUTOMATIC TRANSMISSION`) | | summary | string | What the defect is | | consequence | string | What can happen because of it | | remedy | string | The fix and whether it's free of charge | | notes | string | Additional manufacturer notes | | reportReceivedDate | string | Date NHTSA received the report | | parkIt | bool | **Do-not-drive** warning | | parkOutside | bool | Park-outside (fire risk) warning | | overTheAirUpdate | bool | Remedy delivered as an OTA software update | #### Complaints | Field | Type | Description | |---|---|---| | odiNumber | int | NHTSA complaint ID (ODI number) | | crash | bool | A crash was reported | | fire | bool | A fire was reported | | numberOfInjuries | int | Reported injuries | | numberOfDeaths | int | Reported deaths | | dateOfIncident | string | When the incident occurred | | dateComplaintFiled | string | When the complaint was filed | | vin | string | Partial VIN, if provided | | components | string | Affected component(s) | | summary | string | The consumer's description | | products | array | Associated products/vehicles | #### Safety ratings (5-star) | Field | Type | Description | |---|---|---| | vehicleId | int | NHTSA vehicle identifier | | vehicleDescription | string | Full vehicle description | | overallRating | string | Overall 5-star rating | | overallFrontCrashRating | string | Front crash rating | | overallSideCrashRating | string | Side crash rating | | rolloverRating | string | Rollover rating | | sidePoleCrashRating | string | Side pole crash rating | | frontCrashDriversideRating | string | Driver-side front crash rating | | frontCrashPassengersideRating | string | Passenger-side front crash rating | | electronicStabilityControl | string | ESC availability | | forwardCollisionWarning | string | FCW availability | | laneDepartureWarning | string | LDW availability | #### VIN decode | Field | Type | Description | |---|---|---| | vin | string | The VIN you submitted | | make / model / modelYear | string/int | Decoded make, model, year | | manufacturer | string | Manufacturer name | | vehicleType | string | Vehicle type | | bodyClass | string | Body class (e.g. SUV/MPV) | | series / trim | string | Series and trim level | | doors | int | Number of doors | | engineCylinders | int | Cylinder count | | displacementL | string | Engine displacement (liters) | | fuelTypePrimary | string | Primary fuel type | | driveType | string | Drivetrain (FWD/RWD/AWD) | | transmissionStyle | string | Transmission style | | engineHP | string | Engine horsepower | | plantCountry / plantCity | string | Assembly plant location | | gvwr | string | Gross vehicle weight rating class | Real output samples for complaints, recalls, and VIN decode are shown in the [Output example](#output-example) section below. ### How to use #### Option A — Complaints or recalls by vehicle list + year range 1. Set **dataType** to `complaints` or `recalls`. 2. In **vehicles**, list the cars you care about using the `Make|Model` pipe format — for example `Toyota|Camry`, `Ford|F-150`. (Plain `Make Model` works too, but the pipe is more precise.) 3. Set **yearFrom** and **yearTo** to define the model-year range. Each vehicle is crossed with every year in that range. 4. Optionally raise **maxResults** if you expect a large haul. 5. Run it. ```json { "dataType": "complaints", "vehicles": ["Honda|Accord", "Toyota|Camry", "Ford|F-150"], "yearFrom": 2020, "yearTo": 2024, "maxResults": 1000 } ```` #### Option B — VIN decode 1. Set **dataType** to `vin-decode`. 2. In **vins**, paste your VINs — full 17-character VINs, or partial VINs using `*` as a wildcard (e.g. `5UXWX7C5*BA`). 3. Run it. Each VIN returns a full set of decoded specifications. ```json { "dataType": "vin-decode", "vins": ["1HGCV1F13MA123456", "5UXWX7C5*BA", "JTMBFREV0JD123456"] } ``` ### Input parameters | Parameter | Type | Default | Description | |---|---|---|---| | dataType | select (`complaints`, `recalls`, `safety-ratings`, `vin-decode`) | `complaints` | Which NHTSA dataset to pull | | vehicles | array of strings | popular US models | `Make\|Model` pairs (e.g. `Toyota\|Camry`); plain `Make Model` also works. Each is crossed with every year in range. Empty = popular US models | | yearFrom | integer | 2018 | First model year | | yearTo | integer | 2024 | Last model year | | vins | array of strings | — | VINs for `vin-decode` mode (17-char or partial with `*`) | | maxResults | integer | 500 | Maximum records to return | | proxyConfiguration | object | — | Optional. The API is open, so proxy is not required | Full input JSON: ```json { "dataType": "complaints", "vehicles": ["Toyota|Camry", "Ford|F-150"], "yearFrom": 2018, "yearTo": 2024, "vins": [], "maxResults": 500, "proxyConfiguration": { "useApifyProxy": true } } ``` ### Output example **Complaint** ```json { "dataType": "complaint", "make": "Honda", "model": "Accord", "modelYear": 2022, "odiNumber": 11752366, "manufacturer": "Honda (American Honda Motor Co.)", "crash": false, "fire": false, "numberOfInjuries": 0, "numberOfDeaths": 0, "dateOfIncident": "09/23/2024", "dateComplaintFiled": "07/23/2026", "vin": "1HGCV3F24NA", "components": "UNKNOWN OR OTHER", "summary": "Infotainment is unresponsive and also ghost touches on its own...", "url": "https://www.nhtsa.gov/?nhtsaId=11752366", "scrapedAt": "2026-07-26T10:36:41Z" } ``` **Recall** ```json { "dataType": "recall", "make": "Ford", "model": "F-150", "modelYear": 2023, "campaignNumber": "23V070000", "manufacturer": "Ford Motor Company", "component": "POWER TRAIN:AUTOMATIC TRANSMISSION", "summary": "...loose bolt which could prevent the transmission from engaging the park gear...", "consequence": "...can result in a rollaway, increasing the risk of a crash or injury.", "remedy": "Dealers will inspect and, if necessary, replace the transmissions, free of charge...", "url": "https://www.nhtsa.gov/recalls?nhtsaId=23V070000", "scrapedAt": "2026-07-26T10:37:00Z" } ``` **VIN decode** ```json { "dataType": "vin-decode", "vin": "5UXWX7C5*BA", "make": "BMW", "model": "X3", "modelYear": 2011, "bodyClass": "Sport Utility Vehicle [SUV]/Multipurpose Vehicle [MPV]", "trim": "xDrive35i", "doors": 4, "engineCylinders": 6, "displacementL": "3.0", "fuelTypePrimary": "Gasoline", "driveType": "AWD/All-Wheel Drive", "engineHP": "300", "plantCountry": "GERMANY", "plantCity": "MUNICH", "gvwr": "Class 1D: 5,001 - 6,000 lb", "scrapedAt": "2026-07-26T10:38:12Z" } ``` ### Tips for best results - **Use the `Make|Model` pipe format** for precision — it maps cleanly to NHTSA's make and model fields and avoids ambiguity in multi-word names. - **Widen the year range** (`yearFrom` / `yearTo`) to pull more volume; each extra year multiplies the records per vehicle. - **Watch the `parkIt` and `parkOutside` flags** on recalls — these mark do-not-drive and park-outside (fire-risk) campaigns that need immediate action. - **Use `crash`, `fire`, `numberOfInjuries`, and `numberOfDeaths`** to triage complaints by severity and surface the serious ones first. - **Use `*` wildcards in VINs** when you only have a partial or a squished VIN pattern — the decoder still returns model-level specs. - **Combine complaints and recalls** for the same vehicle list to see both what owners report *and* what the manufacturer has officially acknowledged. - **Sort by `dateComplaintFiled`** to catch the most recent complaints and spot emerging issues before they become recalls. - **Raise `maxResults`** when covering a big inventory or a popular model — a single model-year can produce hundreds of complaints. - **Leave `vehicles` empty** for a quick sample of popular US models when you're exploring the data. - **Skip the proxy** unless you're running very large batches — the NHTSA API is open and usually needs no proxy at all. ### Integrations Connect the results to the rest of your stack: - **Google Sheets** — push records into a sheet for review or reporting. - **Slack** — post recall or high-severity complaint alerts to a channel. - **Zapier** and **Make** — trigger downstream workflows on every new record. - **Webhooks** — send run results to your own endpoint in real time. - **Schedule** — run daily or weekly to keep a recall/complaint feed fresh for your inventory. ### API usage Run the scraper programmatically via the Apify API. Replace `YOUR_API_TOKEN` with your token. **cURL** ```bash curl -X POST "https://api.apify.com/v2/acts/logiover~nhtsa-vehicle-safety-scraper/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "dataType": "recalls", "vehicles": ["Ford|F-150", "Toyota|Camry"], "yearFrom": 2020, "yearTo": 2024, "maxResults": 500 }' ``` **Node.js** (`apify-client`) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_API_TOKEN' }); const run = await client.actor('logiover/nhtsa-vehicle-safety-scraper').call({ dataType: 'complaints', vehicles: ['Honda|Accord', 'Toyota|Camry'], yearFrom: 2020, yearTo: 2024, maxResults: 1000, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(items); ``` **Python** (`apify-client`) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("logiover/nhtsa-vehicle-safety-scraper").call(run_input={ "dataType": "vin-decode", "vins": ["5UXWX7C5*BA", "1HGCV1F13MA123456"], }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) ``` ### Use with AI agents (MCP) This scraper works as a tool for AI agents through the Apify MCP (Model Context Protocol) server, so an LLM-powered assistant can call it on demand and reason over the results. Point your MCP-capable agent at the Apify MCP server, and it can invoke `logiover/nhtsa-vehicle-safety-scraper` directly. Example prompt: > "Pull open NHTSA recalls for the 2021–2024 Ford F-150 and Toyota Camry, and list any do-not-drive campaigns first." ### FAQ #### Is it keyless — do I need an API key or login? No. It pulls from NHTSA's public open-data endpoints, so there is no API key, token, or login required. #### Which datasets does it cover? Four: consumer **complaints**, safety **recalls**, **5-star safety ratings**, and full **VIN decode**. You pick one per run with the `dataType` parameter. #### Is the data US only? Yes. NHTSA is the US federal road-safety regulator, so the data covers vehicles sold and reported in the United States. #### How many records can one run return? Hundreds to thousands. A single popular model-year can produce hundreds of complaints on its own (for example, **340 complaints** for one model), and crossing multiple vehicles with a wide year range multiplies that. #### What is a campaign number and an ODI number? A **campaign number** (e.g. `23V070000`) is NHTSA's unique ID for a recall. An **ODI number** is the unique ID for a consumer complaint filed with NHTSA's Office of Defects Investigation. #### Are the injury, death, and crash figures real numbers? Yes. `numberOfInjuries` and `numberOfDeaths` come through as integers, and `crash`, `fire`, `parkIt`, and `parkOutside` as booleans — not free text — so you can filter and aggregate directly. #### How do I find do-not-drive recalls? Filter recall records where `parkIt` is `true` (do-not-drive) or `parkOutside` is `true` (fire risk). These flag the most urgent campaigns. #### How accurate is the VIN decode? It uses NHTSA's official vPIC decoder, the same engine behind government VIN lookups. It accepts full 17-character VINs and partial VINs with a `*` wildcard, returning make, model, year, trim, engine, drivetrain, plant, and more. #### Can I export the results? Yes — CSV, JSON, or Excel, plus direct API access. You only pay for the records you actually get. #### Is scraping this data legal? Yes. NHTSA data is US government open data in the public domain. See the [Is it legal?](#is-it-legal) section below. #### How fresh is the data? It's pulled live from NHTSA at run time, so you get the latest recalls and complaints on record. Schedule the run to keep a rolling, up-to-date feed. #### Are there related scrapers? Yes — see [Related scrapers](#related-scrapers) for other official-data tools like SEC EDGAR, FDA data, USASpending, and more. ### Is it legal? Yes. All data returned by this scraper comes from the **National Highway Traffic Safety Administration (NHTSA)**, a US federal agency, and is **US government open data in the public domain**. NHTSA publishes recalls, complaints, safety ratings, and VIN-decode information for public use through its open APIs. This scraper only accesses that publicly available government data and does not require login credentials or bypass any access controls. As always, review how you use and redistribute the data to ensure it fits your specific use case and jurisdiction. ### Related scrapers Explore other official-data scrapers from **logiover**: - **SEC EDGAR** — US company filings, financials, and disclosures. - **FDA Data** — drug, device, and food safety records. - **USASpending** — US federal spending, contracts, and awards. - **ClinicalTrials** — registered clinical study data. - **Grants.gov** — US federal grant opportunities. # Actor input Schema ## `dataType` (type: `string`): Which NHTSA dataset to pull. Recalls & complaints & safety-ratings use the Vehicles + Years below; VIN decode uses the VINs list. ## `vehicles` (type: `array`): One entry per vehicle as 'Make|Model' (e.g. 'Toyota|Camry', 'Ford|F-150'). Plain 'Make Model' also works (first word = make). Each is crossed with every year in the range. Leave empty to use a set of popular US models. ## `yearFrom` (type: `integer`): Earliest model year (inclusive). ## `yearTo` (type: `integer`): Latest model year (inclusive). ## `vins` (type: `array`): Vehicle Identification Numbers to decode (17 chars; a partial VIN with '\*' wildcards is allowed). Used only when Data type = VIN decode. ## `maxResults` (type: `integer`): Maximum records to collect across all vehicles/years. ## `proxyConfiguration` (type: `object`): Optional. The NHTSA API is open, so no proxy is required. ## Actor input object example ```json { "dataType": "complaints", "vehicles": [ "Toyota|Camry", "Honda|Accord", "Ford|F-150" ], "yearFrom": 2018, "yearTo": 2024, "vins": [], "maxResults": 500, "proxyConfiguration": { "useApifyProxy": false } } ``` # Actor output Schema ## `results` (type: `string`): All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "vehicles": [ "Toyota|Camry", "Honda|Accord", "Ford|F-150" ], "vins": [], "proxyConfiguration": { "useApifyProxy": false } }; // Run the Actor and wait for it to finish const run = await client.actor("logiover/nhtsa-vehicle-safety-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "vehicles": [ "Toyota|Camry", "Honda|Accord", "Ford|F-150", ], "vins": [], "proxyConfiguration": { "useApifyProxy": False }, } # Run the Actor and wait for it to finish run = client.actor("logiover/nhtsa-vehicle-safety-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 '{ "vehicles": [ "Toyota|Camry", "Honda|Accord", "Ford|F-150" ], "vins": [], "proxyConfiguration": { "useApifyProxy": false } }' | apify call logiover/nhtsa-vehicle-safety-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=logiover/nhtsa-vehicle-safety-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "NHTSA Vehicle Safety Scraper — Recalls, Complaints & VIN", "description": "Scrape NHTSA vehicle recalls, owner complaints, 5-star safety ratings and VIN decode data by make, model and year. Keyless official US government data. No API key, no login.", "version": "1.0", "x-build-id": "eZDw6skoeuA8BdRoo" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/logiover~nhtsa-vehicle-safety-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-logiover-nhtsa-vehicle-safety-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/logiover~nhtsa-vehicle-safety-scraper/runs": { "post": { "operationId": "runs-sync-logiover-nhtsa-vehicle-safety-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/logiover~nhtsa-vehicle-safety-scraper/run-sync": { "post": { "operationId": "run-sync-logiover-nhtsa-vehicle-safety-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": { "dataType": { "title": "Data type", "enum": [ "complaints", "recalls", "safety-ratings", "vin-decode" ], "type": "string", "description": "Which NHTSA dataset to pull. Recalls & complaints & safety-ratings use the Vehicles + Years below; VIN decode uses the VINs list.", "default": "complaints" }, "vehicles": { "title": "Vehicles (Make|Model)", "type": "array", "description": "One entry per vehicle as 'Make|Model' (e.g. 'Toyota|Camry', 'Ford|F-150'). Plain 'Make Model' also works (first word = make). Each is crossed with every year in the range. Leave empty to use a set of popular US models.", "items": { "type": "string" } }, "yearFrom": { "title": "Model year from", "minimum": 1990, "maximum": 2030, "type": "integer", "description": "Earliest model year (inclusive).", "default": 2018 }, "yearTo": { "title": "Model year to", "minimum": 1990, "maximum": 2030, "type": "integer", "description": "Latest model year (inclusive).", "default": 2024 }, "vins": { "title": "VINs (VIN decode only)", "type": "array", "description": "Vehicle Identification Numbers to decode (17 chars; a partial VIN with '*' wildcards is allowed). Used only when Data type = VIN decode.", "items": { "type": "string" } }, "maxResults": { "title": "Max results", "minimum": 1, "maximum": 1000000, "type": "integer", "description": "Maximum records to collect across all vehicles/years.", "default": 500 }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "Optional. The NHTSA API is open, so no proxy is required." } } }, "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 } } } } } } } } } } ```