NHTSA Vehicle Safety Scraper: Up to 1,000 Free Results a Month (2026)

Each decoded VIN record carries 13 specs, including the engine size, body class, fuel type, and assembly plant country. This safety scraper processes real-time safety data directly from the official United States government database. A thousand records cost $5.00 on the free-plan price, and you can test it on Apify's free plan with no credit card required. This is for automotive developers, fleet operators, and vehicle inspectors who need official federal crash records or instant catalog resolution. It is not for anyone who needs live salvage market bids, which the public federal database does not track.

Try it: open NHTSA Vehicle Safety Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try NHTSA Vehicle Safety Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of NHTSA Vehicle Safety Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 20, so a first run returns at most 20 results and costs at most $0.10 in result charges. That is enough to see the real shape of the data before deciding anything.

NHTSA Vehicle Safety Scraper was last updated on 2026-06-06. It is one of 1,725 Actors CrawlerBros publishes on Apify, which together have 692,561 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run NHTSA Vehicle Safety Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The primary cost driver for this scraper is the size of the vins array and the maxItems cap when pulling extensive catalog lists. To test this scraper safely before committing budget, run it with the default maxItems set to 20, which limits your result charges to $0.10. Keeping your batch inputs targeted prevents unnecessary run-start charges on blank queries.

How do you run NHTSA Vehicle Safety Scraper from the API?

The schema marks 1 of its 7 controls as required: mode. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~nhtsa-vehicle-safety-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"getRecalls","vin":"1HGBH41JXMN109186","vins":[],"make":"Toyota","model":"Camry","modelYear":2022,"maxItems":20}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "getRecalls",
  "vin": "1HGBH41JXMN109186",
  "vins": [],
  "make": "Toyota",
  "model": "Camry",
  "modelYear": 2022,
  "maxItems": 20
}

run = client.actor("crawlerbros~nhtsa-vehicle-safety-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "getRecalls",
  "vin": "1HGBH41JXMN109186",
  "vins": [],
  "make": "Toyota",
  "model": "Camry",
  "modelYear": 2022,
  "maxItems": 20
}

const run = await client.actor('crawlerbros~nhtsa-vehicle-safety-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which NHTSA Vehicle Safety Scraper inputs matter, and which can you skip?

The mode control determines which public API endpoint is hit, making it the most critical setting to configure. For catalog searches, most users should keep the make, model, and modelYear inputs aligned to avoid mismatch errors, while leaving the maxItems restricted during initial tests.

• mode (string): What data to fetch from NHTSA/VPIC. Default: "decodeVIN".
• vin (string): 17-character Vehicle Identification Number to decode (mode=decodeVIN with a single VIN).
• vins (array): List of VINs to decode in batch (mode=decodeVIN). When provided, takes precedence over the single vin field. Default: [].
• make (string): Vehicle manufacturer name (e.g. Toyota, Ford, Honda). Used for getRecalls, getSafetyRatings, getComplaints, and getVehicleModels modes.
• model (string): Vehicle model name (e.g. Camry, F-150, Civic). Used for getRecalls, getSafetyRatings, and getComplaints modes.
• modelYear (integer): Four-digit model year (e.g. 2022). Used for getRecalls, getSafetyRatings, getComplaints, and getVehicleModels modes. Default: 2022.
• maxItems (integer): Maximum number of records to return. For getMakes this caps the 12,000+ entry list. Default: 20.

Fixed-choice controls: mode accepts decodeVIN (full vehicle specs from a Vehicle Identification Number), getVehicleModels (Vehicle Models - all models for a make and year (VPIC)), getRecalls (Recalls - official NHTSA safety recalls by make/model/year), getSafetyRatings (Safety Ratings - NCAP crash test star ratings by make/model/year), getComplaints (Consumer Complaints - driver-reported safety issues by make/model/year), getMakes (All Makes - every vehicle make in the NHTSA VPIC database).

What does NHTSA Vehicle Safety Scraper return?

The output records are structured to feed directly into dealer management software or automotive inventory databases. Keep in mind that these public records contain no private owner details, salvage auction prices, or local dealership listings.

decodeVIN

• vin (e.g. 1HGBH41JXMN109186)
• make (e.g. HONDA)
• model (e.g. Civic)
• modelYear (e.g. 2021)
• bodyClass (e.g. Sedan/Saloon)
• engineCylinders (e.g. 4)
• engineDisplacement (e.g. 1.5)
• fuelType (e.g. Gasoline)
• transmissionStyle (e.g. Continuously Variable Transmission(CVT))
• vehicleType (e.g. PASSENGER CAR)
• plantCity (e.g. MARYSVILLE)
• plantCountry (e.g. UNITED STATES (USA))
• scrapedAt (e.g. 2026-06-03T10:00:00+00:00)

getRecalls

• nhtsaId (e.g. 20V682000)
• manufacturer (e.g. Toyota Motor Engineering)
• make (e.g. TOYOTA)
• model (e.g. CAMRY)
• modelYear (e.g. 2022)
• subject (e.g. Fuel Pump May Fail)
• component (e.g. FUEL SYSTEM, GASOLINE:DELIVERY:FUEL PUMP)
• summary (e.g. The fuel pump impeller may crack and cause th...)
• consequence (e.g. If the engine stalls while driving, a crash m...)
• remedy (e.g. Dealers will replace the fuel pump assembly, ...)
• reportReceivedDate (e.g. 09/17/2020)
• scrapedAt (e.g. 2026-06-03T10:00:00+00:00)

getSafetyRatings

• make (e.g. TOYOTA)
• model (e.g. CAMRY)
• modelYear (e.g. 2022)
• vehicleDescription (e.g. 2022 Toyota Camry 4 DR FWD)
• overallRating (e.g. 5)
• overallFrontCrashRating (e.g. 5)
• overallSideCrashRating (e.g. 5)
• rolloverRating (e.g. 4)
• scrapedAt (e.g. 2026-06-03T10:00:00+00:00)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open NHTSA Vehicle Safety Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select the desired retrieval type in the mode control, choosing decodeVIN for single or batch analysis, or getRecalls to pull campaign documents.
2. For batch decoding, paste your list of vehicle identifiers into the vins array, which overrides any single identifier in the vin field.
3. Input the manufacturer name exactly in the make field and the model name in the model field to target searches like getRecalls or getSafetyRatings.
4. Specify the target vehicle year in the modelYear field to narrow down structural ratings and complaint patterns.
5. Set the maxItems limit to 20 for initial testing to inspect the output payload without consuming excess resources.
6. Execute the run and review the dataset structure, checking that the returned fields align with the selected operation mode.
7. Scale up the maxItems limit to pull complete recall lists or bulk VIN profiles once you confirm the field mapping.

How do you apply it? Three worked playbooks

These are NHTSA Vehicle Safety Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Fleet & Insurance

Outcome: Decode VINs in bulk to enrich vehicle databases

Configure: Set mode to "decodeVIN", add a list of identifiers to the vins array, and set maxItems to 100.

Working method: Input the array of target identifiers, run the scraper, and extract the generated specs. Compare the returned bodyClass and engineCylinders against your master inventory to fill in empty specifications.

Deliverable: A spreadsheet mapping raw 17-character VINs to specific body classifications, engine types, and manufacturing plants.

Stop condition: The run completes but the resulting records contain empty make or model fields due to invalid VIN formats.

Use case 2: Safety Research

Outcome: Track recall history and complaint patterns by make/model

Configure: Set mode to "getRecalls", enter "Toyota" in make, "Camry" in model, 2022 in modelYear, and set maxItems to 200.

Working method: Run the Actor for the target model year to collect active campaigns. Aggregate the output by the component field to identify recurring failure points.

Deliverable: A structured dataset containing NHTSA campaign IDs, affected components, structural summaries, and manufacturer remedies.

Stop condition: The returned dataset contains zero results for a known volume model year, indicating a connection failure or rate block.

Use case 3: Automotive Apps

Outcome: Look up NCAP ratings to compare vehicle safety

Configure: Set mode to "getSafetyRatings", enter "Honda" in make, "Civic" in model, and 2021 in modelYear.

Working method: Execute the scraper to retrieve NCAP safety parameters. Verify the presence of overallFrontCrashRating and rolloverRating fields in the dataset.

Deliverable: A table of crash test star ratings mapped to specific vehicle description variants.

Stop condition: The overallRating field returns null or missing for a mainstream vehicle model.

What breaks, and how do you design around it?

When queries return empty results, check that your make and model strings use standard manufacturer spelling. If you run into structural changes in safety data over different years, write your ingestion parser to handle varying payload schemas across older vehicle models.

When should you not use NHTSA Vehicle Safety Scraper?

Do not use this scraper if you need to monitor live salvage car auctions or local vehicle pricing. If you need to search insurance listings or bid history, use IAAI Salvage Vehicle Auctions Scraper instead. If you are specifically tracking localized consumer listings in Canada, Autotrader Vehicle Scraper is the correct tool. For European marketplaces, rely on Mobile De Vehicle Scraper. If your objective is tracking financial fraud and consumer lending complaints rather than physical road safety, use the CFPB Consumer Complaints Scraper.

What should you check before trusting the output?

• Verify that the vin field in the decodeVIN output is populated with a valid 17-character string and is not null.
• Check that overallRating under the getSafetyRatings mode is a valid string representation of star counts, typically ranging from 1 to 5.
• Monitor the scrapedAt timestamp to verify that records are being pulled from the live NHTSA database in real time.
• Set up an automated filter to flag records where the make or model fields return empty, which suggests mismatched search terms.
• Assert that the nhtsaId field exists on every recall record to prevent duplicate processing in your downstream databases.

None of this proves a record is correct. It gives a scheduled NHTSA Vehicle Safety Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

Are there any proxy requirements or extra costs for this scraper?

No. The US National Highway Traffic Safety Administration hosts public APIs that require no authorization, registration, or API keys. The scraper runs without proxy servers, meaning your only expenses are the standard platform usage and the result charge of $5.00 per 1,000 results on the free plan.

Can I test the scraper's features without spending money?

Yes. Apify's free plan includes $5.00 of monthly usage with no credit card required. This covers up to 1,000 results. If you use the example input that caps maxItems at 20, your first run will return at most 20 results and cost at most $0.10 in result charges, making it safe to explore.

What happens if a VIN is invalid or cannot be decoded?

The underlying VPIC API performs validation on the 17-character string. If an invalid identifier is passed, the scraper will still run and return a response, but the specific specification fields like engine details or body class will be empty.

How often is the recall data updated?

The scraper pulls directly from the live federal databases. This means that as soon as a manufacturer registers a safety campaign or recall notice with the government, those records are instantly accessible to your scraper runs.

Are safety ratings available for all vehicles?

No. Crash ratings depend on physical testing. Only vehicles that have gone through the official NCAP testing program will have valid star ratings. Rare, imported, or heavy-duty commercial models will return empty safety rating objects.

Where to go next

When you are ready to run it, open NHTSA Vehicle Safety Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• Australia Product Safety Recalls Scraper: Search Australia's official product recall register (ACCC Product Safety Australia).
• IAAI Salvage Vehicle Auctions Scraper: Scrape IAAI (Insurance Auto Auctions) salvage and insurance vehicle listings.
• Autotrader Vehicle Scraper: Extract vehicle listings from Autotrader.ca including make, model, year, price, mileage, dealer info, photos, and more.
• Mobile De Vehicle Scraper: Scrape vehicle listings from mobile.de, Germany's largest online car marketplace.
• USDA FSIS Recalls Scraper: Scrape USDA Food Safety and Inspection Service (FSIS) recall data - meat, poultry, and egg product recalls and public health alerts.
• Row52 Junkyard & Salvage Yard Parts Scraper: Find which self-service junkyard (Pick-n-Pull) has a matching donor vehicle in stock.
• ClassicCars.com Scraper: Scrape ClassicCars.com listings - collector, classic, and muscle car classifieds.
• CFPB Consumer Complaints Scraper: Scrape consumer financial complaints from the Consumer Financial Protection Bureau (CFPB) public database.

Related guides:

• IAAI Salvage Vehicle Auctions Scraper: Practical Operational Playbooks
• Copart Public Search Scraper: 39 Data Fields per Record (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-28.

• Actor last updated by its maintainers on 2026-06-06.

• Run outcome figures cover the 30 day public window ending 2026-09-28.

• NHTSA Vehicle Safety Scraper on Apify