# NHTSA Vehicle Safety Scraper - Recalls, Complaints & Ratings (`scrapersdelight/nhtsa-vehicle-safety-scraper`) Actor

Scrape NHTSA vehicle safety data by make/model/year, VIN, NHTSA id or date window: recalls with affected vehicles and PDFs, owner complaints with crash/fire/injury flags, NCAP crash-test ratings, defect investigations, service bulletins, VIN decoding. Monitor mode. No API key.

- **URL**: https://apify.com/scrapersdelight/nhtsa-vehicle-safety-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Business, Developer tools, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 1,000 recall records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does NHTSA Vehicle Safety Scraper do?

**NHTSA Vehicle Safety Scraper** pulls US vehicle safety records from NHTSA's own public APIs: **recalls**, **owner complaints**, **NCAP 5-star crash-test ratings**, **defect investigations**, **manufacturer communications (technical service bulletins)**, a **one-row safety summary per vehicle**, and **VIN decoding**. Look vehicles up by make, model and year, by VIN, by NHTSA id (recall campaign, complaint ODI number, investigation, bulletin), or pull **everything NHTSA logged in a date window** across all vehicles. Built for used-car marketplaces, dealers, insurers, fleet managers, repair shops, law firms and safety researchers.

Also known as: NHTSA recall scraper, NHTSA complaints API, vehicle recall lookup, VIN recall check, NCAP crash test ratings API.

- 🚨 **Recalls with the detail other tools drop** - Do Not Drive and Park Outside advisories, over-the-air fixes, units affected, every affected vehicle with production dates, and the PDF documents (Part 573 report, owner letters).
- 📝 **Every owner complaint** - crash, fire, injury and death flags, components, incident and filing dates, partial VIN, owner city and state, full narrative.
- ⭐ **Crash-test ratings for every tested trim** - overall, frontal, side, side pole and rollover stars, ESC / forward collision / lane departure, crash photos, videos and report PDFs.
- 🔎 **Investigations linked to the vehicle by NHTSA itself** - Preliminary Evaluations, Engineering Analyses, Recall Queries, with documents and the recalls they led to.
- 🔑 **VIN in, records out** - decode up to thousands of VINs (about 150 vPIC fields), then the decoded vehicle's recalls, complaints and the crash-test variant that matches the VIN.
- 📅 **What's new at NHTSA** - every recall, complaint and investigation logged in a date window, each completed with make, model, year and components, optionally for chosen makes only.
- 🔁 **Monitor mode** - schedule it and get only records you have not received before.
- 🧾 No login, no API key, no proxy needed.

### What data can you get from NHTSA?

<table>
<tr><td>🚨 Recall campaign number</td><td>🧩 Component path</td><td>⛔ Do Not Drive / Park Outside</td></tr>
<tr><td>📄 Summary, consequence, remedy</td><td>🔢 Units affected</td><td>🚙 Affected vehicles + production dates</td></tr>
<tr><td>📎 Recall PDFs (Part 573, owner letters)</td><td>📡 Over-the-air remedy flag</td><td>📝 Complaint ODI number + narrative</td></tr>
<tr><td>💥 Crash / 🔥 fire flags</td><td>🩹 Injuries / deaths reported</td><td>📍 Owner city + state</td></tr>
<tr><td>⭐ Overall + frontal + side + rollover stars</td><td>🎥 Crash test photos, videos, reports</td><td>🛡️ ESC, FCW, lane departure</td></tr>
<tr><td>🔎 Investigation type + status</td><td>🗓️ Open / close dates</td><td>🔧 Service bulletin number + summary</td></tr>
<tr><td>📊 Per-vehicle counts, top complaint components</td><td>🔑 Decoded VIN (engine, body, plant, ADAS)</td><td>🎯 NCAP variant matched to the VIN</td></tr>
</table>

### How to scrape NHTSA with NHTSA Vehicle Safety Scraper

1. [Sign up for a free Apify account](https://console.apify.com/sign-up) - the free plan includes monthly credit.
2. Open **NHTSA Vehicle Safety Scraper** in the Apify Console.
3. Pick **Look up by** (Vehicles, VINs, NHTSA IDs or Latest NHTSA activity) and fill the matching list, e.g. `Honda, Accord, 2020`.
4. Choose the **Record types** and any filters.
5. Click **Start**.
6. Download the results as JSON, CSV, Excel or HTML, or read them through the API.

### ⬇️ Input

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `vehicles` | `vehicles`, `vins`, `ids` or `recent` (latest NHTSA activity). Inferred from the list you fill when an API caller leaves it out. |
| `vehicles` | list | demo `Honda, Accord, 2020` | `Make, Model, Year` lines. Year ranges (`Ford, F-150, 2015-2018`) and every model of a make (`Ford, *, 2020`) work. |
| `vins` | list | - | 17-character VINs. Duplicates are removed. |
| `nhtsaIds` | list | - | `20V771000` or `20V771` (recall), `11770490` (complaint ODI), `EA24002` (investigation), `MC-11037688` (bulletin). |
| `recordTypes` | multi-select | recalls, complaints, safetyRatings, investigations | Add `manufacturerCommunications` (bulletins) and `vehicleSummary`. |
| `includeDetails` | boolean | `true` | Affected vehicles + PDF documents on recall and investigation rows. |
| `includeVinDecode` | boolean | `true` | VIN mode: one decoded-specification row per VIN. |
| `dateFrom` / `dateTo` | string | - | `YYYY-MM-DD` or `30d`, `12w`, `6m`, `1y`, `ytd`. Latest-activity mode defaults to `7d`. |
| `complaintSeverity` | select | `any` | `anySevere`, `crash`, `fire`, `crashOrFire`, `injury`, `death`, `injuryOrDeath`. |
| `componentKeywords` | list | - | e.g. `AIR BAGS`, `SERVICE BRAKES`, `FUEL`. |
| `keywords` / `excludeKeywords` | list | - | Words in subject, summary, consequence or remedy. |
| `parkItOnly` | boolean | `false` | Recalls with a Do Not Drive or Park Outside advisory only. |
| `investigationStatus` | select | `any` | `open` or `closed`. |
| `minOverallRating` | integer | `0` | Crash-test rows with at least this many overall stars. |
| `makes` | list | - | Latest-activity mode: only these makes. |
| `monitorMode` / `monitorKey` | boolean / string | `false` / - | Only records not delivered by earlier runs; a name keeps separate memories. A recall or investigation delivered without its affected vehicles and documents (`includeDetails` off, or the lookup failed) is delivered once more, with them, by a later run that reads them. |
| `maxResults` | integer | `100` | Rows across all vehicles and types (shared so each vehicle gets rows). `0` = no limit. |
| `maxComplaintsPerVehicle` | integer | `0` | Newest complaints first; `0` = all. |
| `includeComplaintText` | boolean | `true` | Off = complaint rows without the narrative. |
| `proxyConfiguration` | proxy | none | Not needed. If NHTSA ever refuses the run's IP, the run moves to Apify residential (US) within a small budget. |

API callers of other NHTSA actors can also send `make` / `model` / `modelYear`, `vin`, `campaignNumbers`, `odiNumbers`, `maxItems`, `onlyNew` and `includeRecalls` / `includeComplaints` / `includeSafetyRatings` / `includeInvestigations`.

#### Input JSON

```json
{
  "mode": "vehicles",
  "vehicles": ["Honda, Accord, 2020", "Ford, F-150, 2015-2016"],
  "recordTypes": ["recalls", "complaints", "safetyRatings", "investigations", "vehicleSummary"],
  "complaintSeverity": "anySevere",
  "maxResults": 500
}
```

#### Type the model the way you say it

NHTSA files some vehicles under longer names: a 2015 F-150 is filed as `F-150 SUPER CREW`, `F-150 SUPERCAB` and `F-150 REGULAR CAB`, and asking NHTSA for plain `F-150` returns nothing. When your model name has no exact match, the actor reads every NHTSA model that starts with it and removes the duplicates (a recall shared by the three cab models is one row). The row's `model` shows the name NHTSA used.

#### VINs: what "the VIN's recalls" means

A VIN is decoded with NHTSA's vPIC decoder and the records come from the decoded make, model and year - the same as typing the vehicle. NHTSA's open APIs do not say whether a recall was already repaired on one specific VIN. For crash tests, the variant matching the VIN (drive, doors, pickup cab, side air bags) is marked `matchesVin: true`; when the VIN does not single one out, every tested variant is returned.

#### Latest NHTSA activity

`mode: "recent"` walks NHTSA's own lists newest first: about 250 complaints and 4 recalls are logged per day, and 4,184 investigations exist in total. Each row is completed with make, model, year and components. With `makes`, complaints are pre-screened by decoding their partial VIN, so only likely matches are looked up.

### ⬆️ Output

One row per record; `recordType` says which. A real recall row (Honda Accord 2020, trimmed):

```json
{
  "recordType": "recall",
  "campaignNumber": "26V332000",
  "make": "HONDA", "model": "ACCORD", "modelYear": 2020,
  "subject": "Air Bags May Deploy Unintentionally During a Crash",
  "component": "AIR BAGS:SENSOR:OCCUPANT CLASSIFICATION:FRONT PASSENGER",
  "consequence": "Air bags that deploy unintentionally during a crash increase the risk of injury.",
  "reportReceivedDate": "2026-05-21",
  "potentialUnitsAffected": 98892,
  "parkIt": false, "parkOutside": false, "overTheAirUpdate": false,
  "affectedVehiclesCount": 92,
  "affectedVehicles": [{ "make": "ACURA", "model": "MDX", "modelYear": 2020, "productionDates": "Unknown - 12/22/2020" }],
  "documentsCount": 22,
  "documents": [{ "title": "Recall 573 Report", "url": "https://static.nhtsa.gov/odi/rcl/2026/RCLRPT-26V332-6150.pdf" }]
}
```

A real complaint row (trimmed):

```json
{
  "recordType": "complaint",
  "odiNumber": 11770278,
  "make": "HONDA", "model": "ACCORD", "modelYear": 2020,
  "dateComplaintFiled": "2026-10-10", "dateOfIncident": "2025-09-01",
  "crash": false, "fire": false, "numberOfInjuries": 0, "numberOfDeaths": 0,
  "components": "ELECTRICAL SYSTEM,AIR BAGS",
  "vin": "1HGCV2F34LA",
  "consumerCity": "JEFFERSON CITY", "consumerState": "TN",
  "summary": "The Supplemental Restraint System Problem message along with the airbag light comes and goes ..."
}
```

#### Fields and measured fill

Measured on the runs of 2026-10-14 (Accord 2020, F-150 2015 + Silverado 1500 2020, six VINs, a 7-day window):

| Record | Fields always filled | Partly filled (why) |
|---|---|---|
| recall | campaign, subject, component path, summary, consequence, remedy, report date, units affected, park-it / park-outside / OTA, affected vehicles, documents | `mfrCampaignNumber` 80% (NHTSA writes "Refer to Comments"), `notes` 80% |
| complaint | ODI number, filing + incident dates, crash, fire, injuries, deaths, components, narrative | partial `vin` 92-98%, owner city/state 69-100% (not every owner gives one) |
| safetyRating | variant, overall / frontal / side / rollover stars, ESC, FCW, LDW, report PDFs | side pole, combined ratings, videos 55-100% (not every variant had every test) |
| investigation | number, type + label, status, subject, plain-text summary, open date, components | close date (open ones have none) |
| manufacturerCommunication | bulletin number, NHTSA id, summary, date, components | PDF documents only on id lookups |
| vehicleSummary | every count, top 5 complaint components, NCAP best/worst | - |
| vinDecode | VIN, decoded, error code/text, make, model, year | ~40-75 of ~150 vPIC fields per VIN (vPIC leaves the rest blank) |

Not shipped: `rolloverPossibility2` (NHTSA returns 0.0 on every record we sampled - a placeholder, not a probability); a bulletin's manufacturer component system and communication type (only in a separate NHTSA flat file, not the API).

### Use cases

- 🚗 **Used-car marketplaces and dealers** - show open recalls and crash ratings on every listing; flag Do Not Drive recalls.
- 🛡️ **Insurers and fleet managers** - screen VIN lists for recalls, investigations and complaint trends.
- 🔧 **Repair shops** - pull service bulletins and complaint patterns before diagnosing a car.
- ⚖️ **Law firms and researchers** - every complaint with crash, fire, injury and death flags, plus investigation documents.
- 📈 **Manufacturers and suppliers** - monitor new complaints and investigations for your makes every day.
- 📰 **Journalists** - what NHTSA logged this week, across every vehicle.

### How much does it cost to scrape NHTSA?

Pay per record delivered, no start fee:

| Record | Price |
|---|---|
| Recall | $0.00001 |
| Complaint | $0.00045 |
| Crash-test rating | $0.00045 |
| Investigation | $0.009 |
| Service bulletin | $0.0018 |
| Vehicle summary | $0.0018 |
| VIN decoded | $0.000045 (VINs that do not decode are free) |

| Run | Rows | Price |
|---|---|---|
| Prefilled demo (Accord 2020, 20 rows) | 5 recalls, 13 complaints, 1 rating, 1 investigation | ~$0.015 |
| One vehicle, default record types (Accord 2020) | 5 recalls, 364 complaints, 1 rating, 1 investigation | ~$0.17 |
| Two pickups, every record type (F-150 2015 + Silverado 1500 2020) | 4,004 rows incl. 1,793 bulletins | ~$4.28 |
| A week of new complaints, all makes (NHTSA logs ~250 a day) | ~1,750 | ~$0.79 |

Rows removed by your filters, duplicates and rows a monitor already delivered are never delivered or charged. Set `maxResults` or a maximum charge per run to cap spending.

### Integrations, API, scheduling & MCP

Schedule a daily run with `monitorMode` on to receive only new recalls and complaints, and send them to Google Sheets, Slack, Make, Zapier or n8n through Apify integrations or webhooks. Call it from code with the [Python](https://docs.apify.com/api/client/python) or [JavaScript](https://docs.apify.com/api/client/js) client, or the actor's API tab. AI agents can use it through the Apify MCP server (`https://mcp.apify.com`).

### More vehicle and registry scrapers

- [JDM VIN Decoder](https://apify.com/scrapersdelight/jdm-vin-chassis-decoder) - Japanese chassis numbers to production date and options.
- [Bring a Trailer Scraper](https://apify.com/scrapersdelight/bringatrailer-results-scraper) - sold prices and VINs from BaT auctions.
- [Cars.com Dealer Scraper](https://apify.com/scrapersdelight/cars-com-dealer-scraper) - US car dealer leads.
- [FMCSA Carrier Scraper](https://apify.com/scrapersdelight/fmcsa-carrier-scraper) - USDOT / MC carriers with contacts.
- [FAA Aircraft Registry Scraper](https://apify.com/scrapersdelight/faa-aircraft-registry-scraper) - registered aircraft and owners.
- [All ScrapersDelight actors](https://apify.com/scrapersdelight)

### Limits & empty runs

- Speed (2026-10-14): the 20-row demo in 3-10 s; 100 rows in ~3 s once NHTSA's cache is warm; 4,004 rows (two pickups, every record type) in 45 s.
- NHTSA's API refuses an IP that sends bursts (about 100 requests in a second). The actor paces itself at 6 requests per second and pauses on a refusal.
- A vehicle NHTSA does not list is reported as not found in `RUN_SUMMARY`; a vehicle with no records returns no rows. Neither is charged.
- If NHTSA cannot be reached at all, the run fails instead of returning "no records".

### ❓ FAQ

#### How much does NHTSA Vehicle Safety Scraper cost?

You pay per record delivered (table above), with no start fee. The 20-row demo costs about $0.015; a whole vehicle with all 364 complaints about $0.17.

#### Can NHTSA Vehicle Safety Scraper check recalls by VIN?

Yes. Put VINs in `vins`: each is decoded and the decoded vehicle's recalls, complaints and crash tests are returned, with the matching crash-test variant marked. NHTSA's open APIs do not say whether a specific VIN's recall was already repaired.

#### Does NHTSA Vehicle Safety Scraper return complaints with crash and injury data?

Yes. Every complaint has `crash`, `fire`, `numberOfInjuries` and `numberOfDeaths` as the owner reported them, and `complaintSeverity` keeps only the serious ones.

#### Can I look up a recall campaign or complaint number with NHTSA Vehicle Safety Scraper?

Yes. `nhtsaIds` takes recall campaigns (`20V771` or `20V771000`), complaint ODI numbers, investigation numbers (`EA24002`) and bulletins (`MC-11037688`).

#### Can NHTSA Vehicle Safety Scraper give me only new recalls each day?

Yes. Turn on `monitorMode` and schedule the run; records an earlier run delivered are skipped and not charged. For the whole database, use Latest NHTSA activity with `dateFrom: "1d"`.

#### Why did NHTSA Vehicle Safety Scraper return no results for my model?

Check the year and make; the actor already tries NHTSA's longer model names (F-150 -> F-150 SUPER CREW). `RUN_SUMMARY` lists each vehicle as found, not found or unreachable, and filters that removed rows.

#### Does NHTSA Vehicle Safety Scraper need an NHTSA API key or login?

No. It reads NHTSA's public APIs (api.nhtsa.gov and vpic.nhtsa.dot.gov). No key, login or proxy.

#### Can I use NHTSA Vehicle Safety Scraper through the Apify API or an MCP server?

Yes - the API tab shows ready-made calls, and the Apify MCP server exposes it to AI agents.

#### Are the injury and death counts verified?

No. They are what the owner reported to NHTSA, unverified.

#### Is it legal to scrape NHTSA data?

NHTSA publishes these records through its own public APIs with no login. This is an independent tool, not affiliated with NHTSA.

#### Your feedback

Missing a field or a record type? Open an issue on the actor's Issues tab and we will look at it.

# Actor input Schema

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

Vehicles = make, model and year lines. VINs = decode each VIN, then its vehicle's records. NHTSA IDs = recall campaigns, complaint ODI numbers, investigations, bulletins. Latest activity = everything NHTSA logged in the date window.

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

One per line: "Make, Model, Year". A year range works ("Ford, F-150, 2015-2018"); "Ford, \*, 2020" reads every model NHTSA lists for Ford 2020. Used when Look up by = Vehicles.

## `vins` (type: `array`):

17-character VINs, one per line, e.g. 1HGCV1F34LA000001. Each is decoded with NHTSA's vPIC decoder, then its vehicle's records are read. Used when Look up by = VINs.

## `nhtsaIds` (type: `array`):

Recall campaigns (20V771000 or 20V771), complaint ODI numbers (11770490), investigations (EA24002, PE22003) or bulletins (MC-11037688). Used when Look up by = NHTSA IDs.

## `recordTypes` (type: `array`):

Which NHTSA records to return. Bulletins and the vehicle summary come from vehicle and VIN lookups; the date-window feed covers recalls, complaints and investigations.

## `includeDetails` (type: `boolean`):

Adds the affected-vehicle list (make, model, year, production dates) and the PDF documents (Part 573 report, owner letters, investigation resumes) to each recall and investigation row.

## `includeVinDecode` (type: `boolean`):

VIN mode: one row per VIN with the decoded factory specification (engine, body, plant, safety equipment; up to ~150 vPIC fields). VINs that do not decode are listed free.

## `dateFrom` (type: `string`):

Only records dated on or after this day: recall report date, complaint filing date, investigation open date, bulletin date. YYYY-MM-DD or relative: 30d, 12w, 6m, 1y, ytd. Latest activity mode defaults to 7d.

## `dateTo` (type: `string`):

Only records dated on or before this day (included). Same formats as Date from. Empty = up to today.

## `complaintSeverity` (type: `string`):

Keep only complaints that report a crash, a fire, an injury or a death. Counts are as the owner reported them.

## `componentKeywords` (type: `array`):

Keep recalls, complaints, investigations and bulletins whose NHTSA component contains any of these words, e.g. AIR BAGS, SERVICE BRAKES, ENGINE, FUEL. Case-insensitive.

## `keywords` (type: `array`):

Keep records whose subject, summary, consequence or remedy contains any of these words, e.g. "stall", "fire", "software".

## `excludeKeywords` (type: `array`):

Drop records whose subject, summary, consequence or remedy contains any of these words.

## `parkItOnly` (type: `boolean`):

Recalls: keep only those with NHTSA's Do Not Drive (park it) or Park Outside advisory.

## `investigationStatus` (type: `string`):

Investigations: keep open ones, closed ones, or both.

## `minOverallRating` (type: `integer`):

Crash-test ratings: keep variants with at least this many overall stars (1-5). 0 = all.

## `makes` (type: `array`):

Latest NHTSA activity mode: keep only records for these makes, e.g. FORD, TESLA, TOYOTA. Empty = every make.

## `monitorMode` (type: `boolean`):

Skip records an earlier run with the same inputs already delivered (recalls, complaints, ratings, investigations, bulletins). Pairs with a daily or weekly schedule.

## `monitorKey` (type: `string`):

Optional label that keeps a separate memory, e.g. "fleet-a". Empty = one memory per input set.

## `maxResults` (type: `integer`):

Most rows to return across all vehicles and record types; several vehicles share it so each gets rows. A popular model has 300-2,000 complaints. 0 = no limit.

## `maxComplaintsPerVehicle` (type: `integer`):

Newest complaints first. 0 = every complaint NHTSA holds for the vehicle.

## `includeComplaintText` (type: `boolean`):

Keep the owner's complaint narrative. Off = much smaller rows when you only need dates, components and crash/fire/injury flags.

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

Not needed: NHTSA's APIs answer Apify's own network. If NHTSA refuses the run's IP, the run switches to Apify residential (US) automatically within a small budget.

## Actor input object example

```json
{
  "mode": "vehicles",
  "vehicles": [
    "Honda, Accord, 2020"
  ],
  "recordTypes": [
    "recalls",
    "complaints",
    "safetyRatings",
    "investigations"
  ],
  "includeDetails": true,
  "includeVinDecode": true,
  "complaintSeverity": "any",
  "parkItOnly": false,
  "investigationStatus": "any",
  "minOverallRating": 0,
  "monitorMode": false,
  "maxResults": 20,
  "maxComplaintsPerVehicle": 0,
  "includeComplaintText": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per recall, complaint, crash-test rating, investigation, bulletin, vehicle summary or decoded VIN; recordType says which.

## `runSummary` (type: `string`):

RUN_SUMMARY: rows per record type, targets found / not found / unreachable, rows filtered out and why, per-field fill on this run, transport routes.

# 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 = {
    "vehicles": [
        "Honda, Accord, 2020"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "vehicles": ["Honda, Accord, 2020"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/nhtsa-vehicle-safety-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "Honda, Accord, 2020"
  ],
  "maxResults": 20
}' |
apify call scrapersdelight/nhtsa-vehicle-safety-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/nhtsa-vehicle-safety-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FcYTJMbMqAFxSAiM9/builds/clXTcaNkjQlWgp2J3/openapi.json
