# VIN Decoder: NHTSA Vehicle Specs by VIN | $1/1K (`one_dollar_store/vin-decoder-nhtsa`) Actor

$1 per 1,000 results, platform usage included. Decode vehicle identification numbers with the official NHTSA vPIC service: make, model, year, trim, body, engine, fuel, drive type, plant, safety equipment and decoder warnings. Up to 10,000 VINs a run. No key.

- **URL**: https://apify.com/one_dollar_store/vin-decoder-nhtsa.md
- **Developed by:** [One Dollar Store](https://apify.com/one_dollar_store) (community)
- **Categories:** Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/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

## VIN Decoder: vehicle make, model, year and specs from a VIN

**$1 per 1,000 VINs decoded. Platform usage included. No rental, no minimum.**

The four most used VIN decoder actors on the Store charge $1.50 to $2.99 per 1,000 results, and one of them adds platform usage on top (Store prices checked 20 October 2026). This one is $1.00 per 1,000, with usage included.

[Open it in Apify Console](https://console.apify.com/actors/8cyh32Fh3McDfdCNx/input)

### What it costs

| VINs decoded | This actor | Four most used rivals |
|---|---|---|
| 1,000 | $1.00 | $1.50 to $2.99 |
| 10,000 | $10.00 | $15.00 to $29.90 |
| 100,000 | $100.00 | $150.00 to $299.00 |

Plus $0.001 per run. Only decoded VINs are rows, so a VIN the decoder knows nothing about is not charged. A monthly check of 2,000 VINs costs about $2.00 a run, and a weekly batch of 500 VINs about $0.50 a run.

The data comes from the official NHTSA vPIC service, the US government's vehicle product information catalog. Give it VINs, get make, model, year, trim, body, engine, fuel, drive type, plant and more, plus the decoder's own warnings.

### Why people switch

- **Lower price, usage included.** $1 per 1,000 with no separate compute bill.
- **Official source.** The specs are what manufacturers submitted to NHTSA, not guesses from a scraped page.
- **Partial VINs and model years.** Use `*` for unknown characters and add a model year after a comma, for example `5UXWX7C5*BA,2011`. Handy when you only have part of a VIN, or for older vehicles where the year is unclear.
- **The decoder's warnings are on every row.** `errorCode` and `errorText` tell you if the check digit is wrong or the VIN is incomplete, so you can sort clean decodes from doubtful ones.
- **Big lists in one run.** VINs go to NHTSA in batches of 50. A run takes up to 10,000 VINs.

### Quick start

1. Open the actor, paste your VINs one per line, press **Start**.
2. Or paste this input:

```json
{ "vins": ["1HGCM82633A004352", "5UXWX7C5*BA,2011"], "includeAllSpecs": true, "maxItems": 100 }
```

3. Download the results as JSON, CSV or Excel, or read them through the API.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/one_dollar_store~vin-decoder-nhtsa/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"vins": ["1HGCM82633A004352", "5UXWX7C5*BA,2011"], "maxItems": 100}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("one_dollar_store/vin-decoder-nhtsa").call(
    run_input={"vins": ["1HGCM82633A004352", "5UXWX7C5*BA,2011"], "maxItems": 100}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["vin"], item["modelYear"], item["make"], item["model"])
```

### Use it from an AI assistant

Claude, ChatGPT, Cursor and other assistants can call this actor through Apify's MCP server. Add it with this server address:

```
https://mcp.apify.com?tools=one_dollar_store/vin-decoder-nhtsa
```

Then ask, for example: "Decode these five VINs and tell me the make, model, year, engine size and where each was built."

### Switching from another VIN decoder

VINs go in `vins`, one per line, with an optional model year after a comma. The core output fields are `vin`, `modelYear`, `make`, `model`, `trim`, `bodyClass`, `vehicleType`, `engineCylinders`, `displacementL`, `fuelTypePrimary` and `plantCountry`. One row is one decoded VIN. Fields the decoder leaves empty are left out of the row, and every further spec the decoder filled in is under `otherSpecs`.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `vins` | list of text | required | One VIN per line, 17 characters. A shorter or partly known VIN works too: write `*` for each unknown character. Add a model year after a comma to help the decoder, for example `5UXWX7C5*BA,2011`. Up to 10,000 lines. |
| `includeAllSpecs` | true or false | true | Adds an `otherSpecs` object to each row with every further field the decoder filled in, such as airbag locations and seat belt types. Switch off for shorter rows. |
| `maxItems` | number | 100 | Most decoded VINs in the run. Minimum 10, maximum 10,000. |

Upper and lower case both work, and the same VIN written twice is decoded once. A line that is not a VIN is refused by the input form before the run starts.

### Output fields

| Field | Meaning |
|---|---|
| `vin` | The VIN as decoded. A partly known VIN keeps its `*` characters. |
| `modelYear`, `make`, `model`, `trim`, `series` | The vehicle. Trim and series only when the decoder knows them. |
| `manufacturer` | Manufacturer registered for the VIN prefix. |
| `vehicleType`, `bodyClass`, `doors`, `seats`, `seatRows` | Kind of vehicle and body. |
| `driveType`, `bodyCabType`, `bedType` | Drive wheels, cab and bed style for trucks. |
| `fuelTypePrimary`, `fuelTypeSecondary`, `electrificationLevel` | Fuel and hybrid or electric level. |
| `engineCylinders`, `displacementL`, `displacementCC`, `engineHP`, `engineKW`, `engineConfiguration`, `engineModel`, `turbo` | The engine. |
| `transmissionStyle`, `transmissionSpeeds` | The gearbox. |
| `gvwr`, `curbWeightLb`, `wheels`, `steeringLocation`, `brakeSystemType` | Weight class and chassis details. |
| `plantCity`, `plantState`, `plantCountry`, `plantCompany`, `destinationMarket` | Where it was built and for which market. |
| `abs`, `esc`, `tractionControl`, `tpms`, `adaptiveCruiseControl`, `forwardCollisionWarning`, `laneDepartureWarning`, `blindSpotMonitoring`, `parkAssist`, `rearCrossTrafficAlert`, `keylessIgnition` | Driver assistance and safety equipment, when the decoder has it. |
| `errorCode`, `errorText`, `additionalErrorText`, `suggestedVin` | What the decoder says about the VIN itself. `0` is a clean decode. `1` means the check digit does not calculate. `6` means the VIN is incomplete. Several codes are joined by commas. |
| `otherSpecs` | Every other field the decoder filled in, as names and text values. |
| `source`, `scrapedAt` | Where the row came from and when this run read it. |

Fields the decoder leaves empty are left out of the row. Newer vehicles carry more fields than older ones.

### Sample results

Real rows from a test run on 20 October 2026, with `otherSpecs` left out here for length.

```json
[
  {"vin": "1HGCM82633A004352", "modelYear": 2003, "make": "HONDA", "manufacturer": "AMERICAN HONDA MOTOR CO., INC.", "model": "Accord", "trim": "EX-V6", "vehicleType": "PASSENGER CAR", "bodyClass": "Coupe", "doors": 2, "fuelTypePrimary": "Gasoline", "engineCylinders": 6, "displacementL": 3, "displacementCC": 2999, "engineHP": 240, "engineConfiguration": "V-Shaped", "engineModel": "J30A4", "transmissionStyle": "Automatic", "transmissionSpeeds": 5, "gvwr": "Class 1C: 4,001 - 5,000 lb (1,814 - 2,268 kg)", "plantCity": "MARYSVILLE", "plantState": "OHIO", "plantCountry": "UNITED STATES (USA)", "errorCode": "0", "errorText": "0 - VIN decoded clean. Check Digit (9th position) is correct", "source": "NHTSA vPIC", "scrapedAt": "2026-10-20T06:08:00.480Z"},
  {"vin": "5UXWX7C5*BA", "modelYear": 2011, "make": "BMW", "manufacturer": "BMW MANUFACTURER CORPORATION / BMW NORTH AMERICA", "model": "X3", "trim": "xDrive35i", "vehicleType": "MULTIPURPOSE PASSENGER VEHICLE (MPV)", "bodyClass": "Sport Utility Vehicle [SUV]/Multipurpose Vehicle [MPV]", "doors": 4, "driveType": "AWD/All-Wheel Drive", "fuelTypePrimary": "Gasoline", "engineCylinders": 6, "displacementL": 3, "displacementCC": 2979, "engineHP": 300, "gvwr": "Class 1D: 5,001 - 6,000 lb (2,268 - 2,722 kg)", "plantCity": "MUNICH", "plantCountry": "GERMANY", "tpms": "Direct", "errorCode": "6", "errorText": "6 - Incomplete VIN", "source": "NHTSA vPIC", "scrapedAt": "2026-10-20T06:08:00.593Z"}
]
```

The second row shows a partly known VIN with a year: the decoder still finds the vehicle and says `Incomplete VIN` in `errorText`.

### Limits

- **10,000 VINs per run.** For more, run again with the next part of the list.
- **Speed.** VINs go to NHTSA in batches of 50, one batch at a time. In our tests 60 VINs took 6 seconds and 500 VINs took 72 seconds, so 10,000 VINs take about 25 minutes. The run timeout is set to one hour by default.
- **Rate limit.** NHTSA does not publish a number for this service. The actor sends at most one request a second, with a User-Agent that names the actor, and tries a failed request up to three times with a pause between tries.
- **A decode is not a vehicle history.** The service reads what the manufacturer filed for the VIN pattern. It does not know owners, accidents, mileage, recalls or price, and two vehicles with the same pattern get the same specs.
- **US market first.** The catalog is built for vehicles sold in the United States. Vehicles made for other markets can come back with few fields, or none.
- **VINs with no match.** When the decoder returns neither a make nor a model, the VIN is not a row and is not charged. The run summary (`RUN_SUMMARY` in the run's key-value store) lists how many were skipped and the first few.
- **Check the decoder code.** A VIN with a wrong check digit or a missing character still returns what the decoder could work out. Sort on `errorCode` to separate clean decodes from doubtful ones.

### FAQ

**How much does it cost to decode 10,000 VINs?**
$10, plus $0.001 for each run.

**Do I pay for compute or proxy on top?**
No. Platform usage is included in the $1 per 1,000 price. No proxy is used.

**Do I need an API key or an NHTSA account?**
No. The actor reads the public NHTSA vPIC service.

**Can I decode a VIN when a character is unreadable?**
Yes. Replace each unknown character with `*`. A wrong check digit does not stop the decode, and the `errorCode` tells you about it.

**Why is the model year sometimes different from what I expected?**
For some VINs the decoder is not sure of the year and says so in `additionalErrorText`. Add the year after a comma and decode again.

**Is it legal?**
The actor reads vehicle data that NHTSA publishes openly for public use, and it does not log in to anything. How you use the data is up to you: follow NHTSA's terms and the law where you live.

**Is this an official NHTSA product?**
No. It is an independent tool and is not affiliated with or endorsed by NHTSA.

**Do I need an Apify account?**
Yes. Actors run from an Apify account, and a free account is enough to start: it includes $5 of platform usage every month. You can [sign up here](https://www.apify.com?fpr=ymnoit). This is a referral link and it costs you nothing.

**Is there a limit on the free plan?**
Yes. A run started from a free plan account delivers the first 10 results, then ends with a message and a link to the plans. Any paid plan returns everything you ask for, up to your own limit. The price per result is the same on every plan.

### More from The One Dollar Store

Every actor here costs $1 per 1,000 results, platform usage included. See the whole store: https://apify.com/one_dollar_store

**Shopping**

- [Amazon Reviews Scraper](https://apify.com/one_dollar_store/amazon-product-reviews-scraper): Public reviews for any Amazon product.
- [AliExpress Product Scraper](https://apify.com/one_dollar_store/aliexpress-product-search-scraper): Products with prices, orders sold and ratings.
- [Etsy Scraper](https://apify.com/one_dollar_store/etsy-listings-scraper): Listings with prices, shops and badges.
- [Carsales Scraper](https://apify.com/one_dollar_store/carsales-car-listings-scraper): Australian car listings with prices and specs.
- [Open Food Facts Scraper](https://apify.com/one_dollar_store/open-food-facts-products-scraper): Food products with nutrition and labels.
- [Kleinanzeigen Scraper](https://apify.com/one_dollar_store/kleinanzeigen-listings-scraper): Classified ads from kleinanzeigen.de.

### Changelog

- October 2026: first release.

# Actor input Schema

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

One vehicle identification number per line, 17 characters. A shorter or partly known VIN works too: use \* for each unknown character. To give the model year, add it after a comma, for example 5UXWX7C5\*BA,2011. Up to 10,000 lines.

## `includeAllSpecs` (type: `boolean`):

Adds an otherSpecs object to each row with all the further fields the decoder filled in (for example airbag locations and driver assistance). Switch off for shorter rows.

## `maxItems` (type: `integer`):

The run stops after this many decoded VINs. Minimum 10, maximum 10,000.

## Actor input object example

```json
{
  "vins": [
    "1HGCM82633A004352",
    "5UXWX7C5*BA,2011"
  ],
  "includeAllSpecs": true,
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "vins": [
        "1HGCM82633A004352",
        "5UXWX7C5*BA,2011",
        "5YJSA3DS*EF",
        "1FTFW1ET*DF",
        "JH4KA756*PC",
        "JTDKN3DU*A0",
        "WBA3A5C5*DF",
        "2T1BURHE*FC",
        "1C4RJFBG*DC",
        "5NPE24AF*FH"
    ],
    "includeAllSpecs": true,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("one_dollar_store/vin-decoder-nhtsa").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 = {
    "vins": [
        "1HGCM82633A004352",
        "5UXWX7C5*BA,2011",
        "5YJSA3DS*EF",
        "1FTFW1ET*DF",
        "JH4KA756*PC",
        "JTDKN3DU*A0",
        "WBA3A5C5*DF",
        "2T1BURHE*FC",
        "1C4RJFBG*DC",
        "5NPE24AF*FH",
    ],
    "includeAllSpecs": True,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("one_dollar_store/vin-decoder-nhtsa").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 '{
  "vins": [
    "1HGCM82633A004352",
    "5UXWX7C5*BA,2011",
    "5YJSA3DS*EF",
    "1FTFW1ET*DF",
    "JH4KA756*PC",
    "JTDKN3DU*A0",
    "WBA3A5C5*DF",
    "2T1BURHE*FC",
    "1C4RJFBG*DC",
    "5NPE24AF*FH"
  ],
  "includeAllSpecs": true,
  "maxItems": 100
}' |
apify call one_dollar_store/vin-decoder-nhtsa --silent --output-dataset

```

## MCP server setup

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

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/8cyh32Fh3McDfdCNx/builds/UhfbOZasQ27kFaOFi/openapi.json