# NHTSA VIN Decoder - Vehicle Specs and Validation (`benthepythondev/nhtsa-vin-decoder`) Actor Decode and validate VINs through the official NHTSA vPIC API. Get make, model, year, engine, body, plant, drivetrain, safety equipment and all non-empty source fields. - **URL**: https://apify.com/benthepythondev/nhtsa-vin-decoder.md - **Developed by:** [Ben](https://apify.com/benthepythondev) (community) - **Categories:** Business, Automation, E-commerce - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $2.00 / 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. 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 VIN Decoder Decode and validate Vehicle Identification Numbers through the official US National Highway Traffic Safety Administration vPIC API. The NHTSA VIN Decoder returns make, model, model year, trim, body, manufacturer, plant, engine, fuel, transmission, drivetrain, dimensions, weight, safety equipment, decode errors, and the complete set of non-empty source fields for every VIN. The Actor accepts a batch of VINs, normalizes spaces and hyphens, deduplicates the input, sends bounded concurrent requests to NHTSA, and saves one structured dataset row per response. It requires no account, browser, residential proxy, or external API key. ### What can you use it for? - Validate VIN format and inspect official decode warnings. - Enrich vehicle inventory with make, model, year, trim, and body data. - Normalize auction, dealership, insurance, fleet, or marketplace records. - Add engine, fuel, transmission, drivetrain, and plant attributes. - Review decoded safety-equipment fields. - Compare a claimed listing description with public VIN specifications. - Route decoded vehicles into a CRM, spreadsheet, database, or workflow. - Create repeatable fleet or auction intake Tasks. The Actor decodes public manufacturer-submitted VIN characteristics. It does not provide vehicle ownership, title status, accident history, service records, lien information, current mileage, market value, or proof that a listing is legitimate. ### Input ```json { "vins": [ "1HGCM82633A004352", "1FTFW1ET5EFA00001" ], "modelYear": null, "maxVins": 10, "concurrency": 5 } ```` #### Input fields | Field | Type | Default | Description | | --- | --- | --- | --- | | `vins` | array | one valid sample VIN | VINs to validate and decode. | | `modelYear` | integer | empty | Optional year hint for partial or ambiguous decoding. | | `maxVins` | integer | `10` | Maximum unique VINs processed, from 1 to 100. | | `concurrency` | integer | `5` | Maximum concurrent NHTSA requests, from 1 to 10. | VIN input is uppercased and stripped of spaces and hyphens. The syntax check expects the standard 17-character VIN alphabet and excludes `I`, `O`, and `Q`. A non-standard value can still be submitted to NHTSA so the output contains the official error text and any partial decode information. `modelYear` is a hint, not an override. Use it only when NHTSA recommends a year for an incomplete or ambiguous identifier. The decoded `model_year` remains the source result. ### Output Each dataset item represents one requested VIN. ```json { "vin": "1HGCM82633A004352", "requested_vin": "1HGCM82633A004352", "is_valid": true, "is_valid_format": true, "error_code": "0", "error_text": "0 - VIN decoded clean. Check Digit (9th position) is correct", "additional_error_text": null, "make_id": 474, "make": "HONDA", "model_id": 1861, "model": "Accord", "model_year": 2003, "trim": "EX-V6", "series": null, "manufacturer": "AMERICAN HONDA MOTOR CO., INC.", "vehicle_type": "PASSENGER CAR", "body_class": "Coupe", "doors": 2, "drive_type": "Front-Wheel Drive", "plant_city": "MARYSVILLE", "plant_state": "OHIO", "plant_country": "UNITED STATES (USA)", "engine_cylinders": 6, "engine_displacement_l": 3, "fuel_type_primary": "Gasoline", "transmission_style": "Automatic", "front_airbag_locations": "1st Row (Driver and Passenger)", "seat_belt_type": "Manual", "decoded_fields": { "VIN": "1HGCM82633A004352", "Make": "HONDA", "Model": "Accord", "ModelYear": "2003" }, "source_api": "NHTSA vPIC DecodeVinValuesExtended", "scraped_at": "2026-07-11T12:00:00+00:00" } ``` #### Validation fields - `is_valid_format` checks the normalized input against the standard 17-character VIN syntax. - `error_code` and `error_text` are returned by NHTSA. - `is_valid` is true only when the syntax check passes and the NHTSA error code is empty or zero. - `suggested_vin` preserves a correction suggested by the API when available. An error does not automatically mean fraud, and a clean decode does not prove ownership, condition, or legal status. Partial, pre-standard, off-road, imported, incomplete, or incorrectly entered identifiers can produce warnings while still returning some useful fields. #### Vehicle fields The normalized top-level fields cover the most reusable attributes: - identity: make, model, year, trim, series, manufacturer; - classification: vehicle type, body class, doors, drive type; - production: plant company, city, state, and country; - powertrain: cylinders, displacement, engine model, horsepower, fuel, electrification, turbo, transmission; - dimensions: GVWR class, curb weight, wheelbase, wheels, wheel sizes, seats, and rows; - safety: airbags, seat belts, ABS, ESC, traction control, TPMS, lane and collision systems; - source diagnostics: error codes, additional error text, and suggested VIN. NHTSA does not populate every field for every year, make, or vehicle type. Missing values stay `null`; the Actor does not infer them from a different model or external database. #### Complete source fields `decoded_fields` contains every non-empty field in the current NHTSA response, preserving original source names and values. This gives advanced users access to electric-vehicle battery fields, bus and motorcycle fields, detailed safety options, regulatory classifications, and future additions without waiting for the normalized schema to change. Use top-level fields for stable integrations and `decoded_fields` for source-complete research. NHTSA can add or rename source fields over time, so downstream systems should tolerate additional keys. ### A practical vehicle-enrichment workflow 1. Start with a small batch of VINs from one trusted source. 2. Keep the original identifier alongside the normalized `vin`. 3. Separate clean decodes from warning and error rows using `is_valid` and `error_code`. 4. Compare decoded make, model, year, and body with the source listing. 5. Route mismatches to manual review instead of rejecting them automatically. 6. Retain `scraped_at` and `source_api` for traceability. 7. Use recall, title, history, and valuation services separately when those facts are needed. 8. Minimize stored vehicle and customer data to the legitimate purpose. For marketplace research, join the result to a vehicle listing dataset by VIN. For safety research, pass the decoded make/model/year into a separate NHTSA recalls workflow. Keeping decode and recall Actors separate prevents duplicate result charges and makes each dataset easier to reason about. ### Scheduling and integrations Save a tested input as an Apify Task, then call it from a schedule, webhook, API, or workflow platform. Results can feed: - Google Sheets or Airtable for reviewed inventory intake; - n8n, Make, or Zapier for enrichment automation; - BigQuery, Snowflake, PostgreSQL, or object storage; - a dealership, auction, fleet, or insurance back office; - Python or JavaScript through the Apify API. For event-driven enrichment, run the Task when a new inventory record arrives rather than repeatedly decoding unchanged VINs. VIN characteristics rarely change; cache a successful decode unless the source record or business requirement changes. ### Pricing This Actor uses transparent pay-per-event pricing: - `$0.005` when the Actor starts. - `$0.002` for each VIN decode row saved to the default dataset. A 100-VIN run costs about `$0.205` in Actor charges before ordinary Apify platform usage. Duplicate VIN inputs are processed and billed once. A row with an official decode warning is still a useful result and is billed because it contains validation status and any partial fields. Failed HTTP requests that produce no row are not billed as results. The price is lower than the closest current competing VIN Decoder Actor's `$0.09` start and `$0.00299` result price. ### Reliability and limits The engine calls NHTSA's public vPIC API directly with no proxy and no browser. Requests have explicit timeouts, up to three bounded retries, and configurable concurrency capped at ten. Input is capped at 100 VINs per run to keep the public service load predictable. Empty overall output fails explicitly instead of creating a misleading successful run. Public government APIs can be temporarily slow or unavailable. NHTSA controls the source data, coverage, error messages, and field definitions. Manufacturer submissions can be incomplete. The Actor preserves source values but cannot certify their accuracy for a specific physical vehicle. ### Responsible use Use this Actor for legitimate vehicle validation and enrichment. Follow NHTSA's API guidance, applicable law, and your organization's policies. Do not use a decoded VIN alone to make legal, credit, insurance, employment, or safety decisions. Obtain appropriate title, ownership, history, inspection, and consent records for the intended use. This Actor is independent and is not affiliated with or endorsed by NHTSA, the US Department of Transportation, or any vehicle manufacturer. ### Frequently asked questions #### Does it require an NHTSA API key? No. It uses the public vPIC endpoint. #### Can it decode several VINs in one run? Yes. Submit up to 100 unique VINs and control concurrency from one to ten. #### Does a clean result prove the car has a clean title? No. VIN decoding describes manufacturer and vehicle attributes. It does not provide title, lien, theft, accident, service, or ownership history. #### Why are some fields null? NHTSA coverage varies by model year, manufacturer, and vehicle type. Missing fields are not guessed. #### What is `decoded_fields`? It is the complete non-empty NHTSA response for that VIN, retained under original source field names. #### Can I schedule it? Yes, but repeated decoding is usually unnecessary. A webhook or intake Task is more efficient for new inventory. ### You might also like - [Vehicle Recalls Intelligence](https://apify.com/benthepythondev/vehicle-recalls-intelligence) for NHTSA recall and complaint research. - [Cars.com Scraper](https://apify.com/benthepythondev/cars-com-scraper) for public US vehicle listings. - [IAAI Vehicle Scraper](https://apify.com/benthepythondev/iaai-vehicle-scraper) for public salvage-auction vehicle details. If the Actor saved time or replaced manual work, leave a Store review. Reviews help prioritize source monitoring, field improvements, and support. Keywords: VIN decoder API, NHTSA VIN decoder, vehicle specifications API, VIN validation, vPIC API, car make model decoder, vehicle enrichment, engine decoder, VIN safety features, batch VIN lookup. # Actor input Schema ## `vins` (type: `array`): Vehicle Identification Numbers to validate and decode. Spaces and hyphens are removed automatically. ## `modelYear` (type: `integer`): Optional model-year hint for partial or ambiguous VIN decoding. ## `maxVins` (type: `integer`): Maximum unique VIN inputs processed in this run. ## `concurrency` (type: `integer`): Maximum concurrent requests to the public NHTSA API. ## Actor input object example ```json { "vins": [ "1HGCM82633A004352", "1FTFW1ET5EFA00001" ], "maxVins": 10, "concurrency": 5 } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "vins": [ "1HGCM82633A004352", "1FTFW1ET5EFA00001" ], "maxVins": 10, "concurrency": 5 }; // Run the Actor and wait for it to finish const run = await client.actor("benthepythondev/nhtsa-vin-decoder").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 = { "vins": [ "1HGCM82633A004352", "1FTFW1ET5EFA00001", ], "maxVins": 10, "concurrency": 5, } # Run the Actor and wait for it to finish run = client.actor("benthepythondev/nhtsa-vin-decoder").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 '{ "vins": [ "1HGCM82633A004352", "1FTFW1ET5EFA00001" ], "maxVins": 10, "concurrency": 5 }' | apify call benthepythondev/nhtsa-vin-decoder --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=benthepythondev/nhtsa-vin-decoder", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "NHTSA VIN Decoder - Vehicle Specs and Validation", "description": "Decode and validate VINs through the official NHTSA vPIC API. Get make, model, year, engine, body, plant, drivetrain, safety equipment and all non-empty source fields.", "version": "1.0", "x-build-id": "hVNaNrlLRPNR3LKJl" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/benthepythondev~nhtsa-vin-decoder/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-benthepythondev-nhtsa-vin-decoder", "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/benthepythondev~nhtsa-vin-decoder/runs": { "post": { "operationId": "runs-sync-benthepythondev-nhtsa-vin-decoder", "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/benthepythondev~nhtsa-vin-decoder/run-sync": { "post": { "operationId": "run-sync-benthepythondev-nhtsa-vin-decoder", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "vins" ], "properties": { "vins": { "title": "VINs", "type": "array", "description": "Vehicle Identification Numbers to validate and decode. Spaces and hyphens are removed automatically.", "default": [ "1HGCM82633A004352" ], "items": { "type": "string" } }, "modelYear": { "title": "Optional model year hint", "minimum": 1980, "maximum": 2100, "type": "integer", "description": "Optional model-year hint for partial or ambiguous VIN decoding." }, "maxVins": { "title": "Maximum VINs", "minimum": 1, "maximum": 100, "type": "integer", "description": "Maximum unique VIN inputs processed in this run.", "default": 10 }, "concurrency": { "title": "Request concurrency", "minimum": 1, "maximum": 10, "type": "integer", "description": "Maximum concurrent requests to the public NHTSA API.", "default": 5 } } }, "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 } } } } } } } } } } ```