# NHTSA VIN Decoder - Batch Vehicle Specifications (`sian.agency/nhtsa-vin-decoder`) Actor

Decode a batch of VINs into vehicle make, model, year, engine, fuel and manufacturing-plant details. Export clean vehicle specifications to JSON, CSV or Excel. Invalid and incomplete decodes stay in the processing report without a result charge.

- **URL**: https://apify.com/sian.agency/nhtsa-vin-decoder.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.88 / 1,000 decoded vehicles

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/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

## NHTSA VIN Decoder - Batch Vehicle Specifications 🚗

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![RockAuto Parts](https://img.shields.io/badge/Store-RockAuto%20Parts-1AE392)](https://apify.com/sian.agency/rockauto-product-scraper?fpr=sian) [![AutoZone Products](https://img.shields.io/badge/Store-AutoZone%20Products-FF6600)](https://apify.com/sian.agency/autozone-product-scraper?fpr=sian) [![Advance Auto Parts](https://img.shields.io/badge/Store-Advance%20Auto%20Parts-E31837)](https://apify.com/sian.agency/advance-auto-parts-product-scraper?fpr=sian)

#### 🚗 One VIN list, 22 vehicle specification and validation fields

##### For inventory teams who need make, model and year in a spreadsheet

### 🔎 What is the NHTSA VIN Decoder — and when should you use it?

The **NHTSA VIN Decoder** turns your list of full VINs into clean, structured rows you can filter, export and feed straight into a spreadsheet, database or AI agent. No account, no portal API key, no browser automation to maintain.

**Use it when you need:** vehicle make, model, year and available engine, fuel and plant details for a VIN list. Invalid and incomplete decodes appear in the processing report.

**Use something else when:** you need a vehicle history or valuation service. You need accident history, owner identities, open recalls or vehicle valuation. This actor returns vehicle specifications only.

### 🤖 Use with AI agents

Already connected to the [Apify MCP server](https://mcp.apify.com)? Just ask for this Actor by name: sian.agency/nhtsa-vin-decoder

**Agentic payments:** Availability of [x402](https://www.x402.org/) and [Skyfire](https://www.skyfire.xyz/) depends on this Actor's current Store eligibility. Check the published listing for supported payment methods. Only clean vehicle rows incur result charges. Invalid and incomplete decodes have no result charge; the platform run-start fee can apply.

Otherwise copy this prompt into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```text
I want vehicle specifications for a VIN list using the Apify Actor `sian.agency/nhtsa-vin-decoder`.

Use it when I need: vehicle make, model, year and available engine, fuel and plant details for a VIN list. Invalid and incomplete decodes appear in the processing report.

Don't use it when: You need accident history, owner identities, open recalls or vehicle valuation. This actor returns vehicle specifications only.

How to call it: choose decode and provide full 17-character VINs in vinCodes. Set modelYear only when the entire list shares that known year.

Start with this input:
{
  "operation": "decode",
  "vinCodes": [
    "1HGCM82633A004352"
  ]
}

Ask me which VINs to decode and whether all vehicles share one known model year, then run the Actor and summarise the results as a table.
```

**Things you can ask your agent for:**

- *Enrich this inventory export with make, model and model year.*
- *Group my fleet by available engine displacement and fuel type.*
- *Show which VINs need correction before I import the vehicle rows.*

Machine-readable API, MCP config and OpenAPI definition for this Actor are published at [apify.com/sian.agency/nhtsa-vin-decoder.md](https://apify.com/sian.agency/nhtsa-vin-decoder.md).

### 📋 Overview

NHTSA VIN Decoder turns your VIN list into vehicle specifications that you can export or join to an inventory table. Start with the prefilled Honda Accord example, then replace it with your own VINs.

- ✅ **Clean vehicle rows:** Each saved vehicle has a make, model, model year and clean validation code.
- 📦 **Batch input:** Paste full VINs into one list instead of entering them on separate pages.
- 🔄 **Duplicate removal:** Repeated VINs are decoded once per run.
- 📄 **Actionable report:** See rejected inputs and the corrections they need.
- 💰 **Per-result billing:** Invalid and incomplete decodes have no result charge. The run-start fee can still apply.

***

### ✨ Features

- 🚙 **Vehicle identity:** Make, model, year, trim and vehicle type.
- 🔧 **Engine details:** Cylinders, displacement and horsepower when available.
- ⛽ **Fuel and drivetrain:** Primary fuel, transmission style and drive type.
- 🏭 **Manufacturing details:** Manufacturer, plant city and plant country.
- ✅ **VIN validation:** Full-length checks and check-digit validation before decoding.
- 📤 **Exports:** Download JSON, CSV or Excel from the dataset.
- 📄 **Processing report:** Review successful decodes and inputs needing attention.
- 🤖 **Automation:** Use Apify schedules, integrations or an AI assistant.

***

### 🎬 Quick Start

Open the actor, leave the example VIN in place and select Start. Open the vehicle dataset when the run finishes. Replace the example with your own VIN list for your next run.

```json
{"operation":"decode","vinCodes":["1HGCM82633A004352"]}
```

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Paste your VINs

Use full 17-character vehicle identification numbers. Add one VIN per entry.

#### Step 2: Start decoding

Leave model year blank for a list containing different years. Set it only if every vehicle shares that known year.

#### Step 3: Export your vehicles

Open **Decoded Vehicles** to export rows. Open **Processing Report** to review validation messages, rejected VINs and any early stop.

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|---|---|---|---|
| `operation` | string | No | Decode; this is the default operation. |
| `vinCodes` | string array | Yes at runtime | Full VINs to decode. The example is prefilled in the form. |
| `modelYear` | integer | No | Known year, 1981–2027, applied to the entire list. Leave blank for mixed years. |

```json
{
  "operation": "decode",
  "vinCodes": ["1HGCM82633A004352", "1M8GDM9AXKP042788"]
}
```

Letters are normalized to uppercase. VINs containing I, O or Q, shorter VINs and invalid check digits are reported without a result charge. An API call with an empty input does not decode the sample VIN.

***

### 📤 Output

The dataset contains successful decodes only. All 22 fields have stable types; optional values are null when unavailable.

| Field | Type | Description |
|---|---|---|
| `vin` | string | Normalized VIN. |
| `make`, `model` | string | Reported make and model. |
| `modelYear` | integer | Decoded model year. |
| `trim` | string or null | Reported trim. |
| `bodyClass`, `vehicleType` | string or null | Body and vehicle classifications. |
| `manufacturer` | string or null | Manufacturer name. |
| `fuelType` | string or null | Primary fuel. |
| `engineCylinders` | integer or null | Engine cylinder count. |
| `engineDisplacementLiters` | number or null | Displacement in liters. |
| `enginePowerHp` | number or null | Reported engine brake horsepower. |
| `transmission`, `driveType` | string or null | Transmission and drivetrain. |
| `plantCity`, `plantCountry` | string or null | Manufacturing location. |
| `errorCode`, `validationMessage` | string | Validation code and explanation. |
| `sourceUrl` | string | Official vehicle details link. |
| `processedAt`, `scrapingDate`, `status` | string | Processing timestamp, date and success status. |

```json
{
  "vin": "1HGCM82633A004352",
  "make": "HONDA",
  "model": "Accord",
  "modelYear": 2003,
  "trim": "EX-V6",
  "bodyClass": "Coupe",
  "vehicleType": "PASSENGER CAR",
  "manufacturer": "AMERICAN HONDA MOTOR CO., INC.",
  "fuelType": "Gasoline",
  "engineCylinders": 6,
  "engineDisplacementLiters": 2.998832712,
  "enginePowerHp": 240,
  "transmission": "Automatic",
  "driveType": null,
  "plantCity": "MARYSVILLE",
  "plantCountry": "UNITED STATES (USA)",
  "errorCode": "0",
  "validationMessage": "0 - VIN decoded clean. Check Digit (9th position) is correct",
  "sourceUrl": "https://vpic.nhtsa.dot.gov/decoder/VinDecoder?VIN=1HGCM82633A004352",
  "processedAt": "2026-10-29T13:00:00.000Z",
  "scrapingDate": "2026-10-29",
  "status": "success"
}
```

The timestamp above illustrates the output format. Missing specifications mean unknown; they do not show that the vehicle lacks that equipment. A decode does not prove a physical vehicle exists.

***

### 💼 Use Cases & Examples

#### 1. Dealer inventory enrichment

Dealership operations teams paste VINs from their stock export. Join the returned make, model and year to the inventory sheet before publishing vehicle descriptions.

#### 2. Fleet data cleanup

Fleet managers decode a mixed-year vehicle list. Use the standardized vehicle type and year fields to find inconsistent inventory labels.

#### 3. Parts catalog preparation

Parts analysts use available engine displacement and body class to group a VIN list. Confirm compatibility against a parts catalog before recommending a part.

#### 4. Automotive data research

Researchers combine vehicle specification rows for analysis. Keep unknown fields as null rather than treating them as evidence that equipment is absent.

#### 5. Vehicle import research

Import analysts check manufacturer and plant details available for US-market vehicles. Use a separate compliance process for import eligibility.

#### 6. Inventory automation

Data engineers schedule VIN enrichment and send the exported rows to a warehouse or spreadsheet. Review the processing report when an input is rejected.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('sian.agency/nhtsa-vin-decoder').call({
  operation: 'decode', vinCodes: ['1HGCM82633A004352']
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('sian.agency/nhtsa-vin-decoder').call(
    run_input={'operation': 'decode', 'vinCodes': ['1HGCM82633A004352']}
)
for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~nhtsa-vin-decoder/run-sync-get-dataset-items?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"operation":"decode","vinCodes":["1HGCM82633A004352"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. Trigger a workflow from an inventory update or schedule.
2. Pass its VIN list to the Apify actor.
3. Read the resulting dataset.
4. Join vehicle rows to the inventory and review rejected inputs in the report.

***

### 📊 Performance & Pricing

The BRONZE rate is $1 per 1,000 clean vehicle decodes on BRONZE, plus $0.005 per run. SILVER is $0.94 and GOLD/PLATINUM/DIAMOND $0.88 per 1,000 decodes. Check the published listing for active pricing.

The FREE plan supports up to 25 clean rows per run at $4 per 1,000 decodes plus $0.05 per run. Paid plans process the full submitted list. Plan and billing limits can stop a run earlier.

Rejected or incomplete decodes have no result charge. A platform run-start fee can apply even when no VIN is decoded. Processing time varies with the list length and service availability.

NHTSA provides its own public VIN decoding service free of charge. This actor charges for managed batches, validation, exports and the processing report. [Check current actor pricing](https://apify.com/sian.agency/nhtsa-vin-decoder?fpr=sian).

***

### ❓ Frequently Asked Questions

**Does it provide accident or ownership history?**

No. It returns manufacturer-reported specifications. It does not return ownership, accident history, valuation or open-recall status.

**Can I use partial VINs?**

This actor accepts full 17-character VINs only. VINs must pass their check digit.

**Does it cover every country?**

Coverage follows manufacturer submissions for vehicles intended for US sale, registration or use. Some imported vehicles are covered; worldwide registration coverage is not promised.

**Why are some specifications null?**

The vehicle record does not contain those values. Null does not mean equipment is absent.

**Are rejected VINs charged?**

They receive no result charge. The platform run-start fee may still apply.

**Do I need a separate vehicle-data API key?**

No. Use the Apify form or your Apify API token for automation.

**What happens if the service is rate limited?**

The run stops requesting vehicles and lists the affected VINs in the report. Schedule a later run and avoid concurrent jobs.

***

### 🐛 Troubleshooting

**A VIN fails its check digit**

Copy it from the vehicle label again. Do not replace a digit by guesswork.

**The VIN is valid but no clean decode is returned**

Check the manufacturer-reported coverage and known model year. Try the VIN separately later.

**The decoded year differs from the year you supplied**

Check your documents or remove model year from a mixed-year list.

**A run ends before the full list is decoded**

Read the processing report for the plan, charge or service-access limit that stopped it.

***

### ⚠️ Trademark Disclaimer

NHTSA and vPIC identify US government services. This actor is independently maintained by SIÁN Agency and is not affiliated with or endorsed by NHTSA or the US Department of Transportation.

### ⚖️ Is it legal to use this vehicle data?

NHTSA publishes vehicle specifications as public information and permits distribution and copying under its [terms of use](https://www.nhtsa.gov/about-nhtsa/terms-use). Access controls and service limits still apply.

The actor does not return owner identities. VINs can become personal data when joined to identifiable people; follow applicable privacy rules, including GDPR, when combining datasets. Vehicle specifications are informational and do not establish safety, compliance or ownership.

***

### 🤝 Support

- 💬 [Report an issue](https://apify.com/sian.agency/nhtsa-vin-decoder/issues).
- ⭐ [Leave a review](https://apify.com/sian.agency/nhtsa-vin-decoder/reviews).
- ✉️ <apify@sian-agency.online>.
- 🌐 [Browse SIÁN Agency actors](https://apify.com/sian.agency?fpr=sian).

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Changelog

This Actor's version history is a separate document: https://apify.com/sian.agency/nhtsa-vin-decoder/changelog.md

# Actor input Schema

## `operation` (type: `string`):

🚗 **VIN DECODING:** Decode one or more full 17-character VINs. Only clean decodes with make, model and model year become dataset rows.

## `vinCodes` (type: `array`):

🚗 **BATCH VIN DECODER:** Add one full 17-character VIN per line. Lowercase letters are accepted. VINs cannot contain I, O or Q. Duplicates are removed. Invalid check digits and incomplete decodes appear in the processing report without a result charge. FREE plans receive up to 25 decodes per run; paid plans process the full list.

## `modelYear` (type: `integer`):

📅 **MODEL YEAR:** Supply the known year only when every VIN in the list belongs to that year. Otherwise leave this blank so each vehicle year is decoded individually. Supported years are 1981 through 2027.

## Actor input object example

```json
{
  "operation": "decode",
  "vinCodes": [
    "1HGCM82633A004352"
  ]
}
```

# Actor output Schema

## `nhtsaVehicles` (type: `string`):

Every vehicle this run returned.

## `scrapingSummary` (type: `string`):

HTML summary showing successful and failed results with key metrics

# 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 = {
    "operation": "decode",
    "vinCodes": [
        "1HGCM82633A004352"
    ]
};

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

# Prepare the Actor input
run_input = {
    "operation": "decode",
    "vinCodes": ["1HGCM82633A004352"],
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/nhtsa-vin-decoder").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 '{
  "operation": "decode",
  "vinCodes": [
    "1HGCM82633A004352"
  ]
}' |
apify call sian.agency/nhtsa-vin-decoder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sian.agency/nhtsa-vin-decoder"
        }
    }
}
```

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/DTptb4RN8k2Nmc7X4/builds/8GbRXsPYTtNNxGwwa/openapi.json