Skip to main content
Enrich

The VIN Decoder API returns the year, make, model and engine behind any VIN

One call turns a VIN into the vehicle's year, make, model, trim, body class, engine, drive type, transmission, build plant and weight class, read from the official US vehicle records. 2 credits per vehicle found.

2 credits per lookupOnly charged on a matchSame credits as every other product
1Lookup VIN Decoder API showing a 17-character VIN split into its manufacturer, vehicle descriptor, check digit, year and plant sections, with the decoded 2019 Chevrolet Silverado RST specification below

2

Credits per vehicle found

about $0.01 on Starter

0

Credits when there is no record

no vehicle, no charge

17

Characters in, one vehicle out

spaces and dashes are fine

NHTSA

Official US vehicle records

the public vPIC database

A VIN comes back as one flat record that your code reads the same way every time

The record is the government's own, read from the official US vehicle records

Every field comes from NHTSA's vPIC database, the public catalog of the build data manufacturers file for the vehicles they sell in the US.

  • Run by the US vehicle safety regulator
  • Factory build data filed by manufacturers
  • A public source, read when you ask

The vehicle arrives as one readable line and as separate fields

You get the line a person would say, such as 2019 Chevrolet Silverado RST, and the year, make, model and trim as fields of their own.

  • Year, make, model and trim
  • Body class and vehicle type
  • Series, doors and manufacturer

The engine and drivetrain are listed field by field

Cylinders, size in litres, fuel type, drive type and transmission come back as separate values, with horsepower and the engine model where the manufacturer filed them.

  • Cylinders and displacement in litres
  • Fuel type and electrification level
  • Drive type and transmission

The weight class and the build plant come with the record

The gross vehicle weight class (GVWR) arrives with its weight range, and the plant comes back as a city, a state and a country.

  • Weight class with its pound and kilogram range
  • Plant city, state and country
  • Safety equipment on file

A VIN that cannot exist is refused before it costs anything

A VIN has 17 characters and never an I, O or Q. One that breaks those rules is refused with a message that names the problem, and no credit is reserved.

  • Length and characters tested first
  • Spaces, dashes and lower case accepted
  • Invalid CSV rows fail without a charge

A wrong check digit comes back as a warning and not as an error

The ninth character is tested against the other sixteen. A mismatch is reported in the result and the VIN is still decoded, because many VINs built outside North America never used a check digit.

  • check_digit_valid and vin_valid flags
  • Warnings in plain English
  • A suggested VIN when the records offer one

A VIN goes in and the vehicle the manufacturer filed comes out

01

You send a 17-character VIN and nothing else

POST the VIN, with or without spaces and dashes. Its length and characters are tested first, so a VIN that cannot exist is refused with a clear message and costs nothing.

request

$ POST /api/v1/vin-decoder

"vin": "1GCUYEED7KZ123456"

> 17 characters, no I, O or Q

02

We read the official US vehicle records and test the check digit

The VIN is decoded against NHTSA's public vPIC database, and the check digit is worked out for every VIN. A record found is billed, and anything else is not.

processing

VIN length and characters tested

Check digit worked out

Official US vehicle records read

Engine, plant and weight class structured

03

You get the vehicle back as one JSON record

Year, make, model, trim, body, engine, drivetrain, plant and weight class arrive in one payload. A vehicle found bills 2 credits, and a VIN the records do not hold bills nothing.

200 OK

vehicle2019 Chevrolet Silverado RST

engine8 cyl, 5.3 L

plantFort Wayne, Indiana

check digit matches2 credits, 0 if not found

One endpoint decodes a VIN and works like every other 1Lookup call

Same authentication, same credit balance, and the same response envelope as every other 1Lookup product. If you have already integrated one endpoint, this one is a URL change.

POST /v1/vin-decoder
curl -X POST https://app.1lookup.io/api/v1/vin-decoder \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "vin": "1GCUYEED7KZ123456" }'

# spaces, dashes and lower case are accepted
#   -d '{ "vin": "1gcu-yeed7-kz123456" }'
200 OK
{
  "success": true,
  "data": {
    "classification": {
      "found": true,
      "vin": "1GCUYEED7KZ123456",
      "vehicle": "2019 Chevrolet Silverado RST",
      "year": 2019,
      "make": "Chevrolet",
      "model": "Silverado",
      "trim": "RST",
      "body_class": "Pickup",
      "engine_cylinders": 8,
      "engine_displacement_l": 5.3,
      "drive_type": "4WD/4-Wheel Drive/4x4",
      "gvwr": "Class 2F: 7,001 - 8,000 lb",
      "check_digit_valid": true,
      "warnings": []
    },
    "insights": {
      "vin_decoder_result": {
        "series": "1500",
        "doors": 4,
        "engine": { "displacement_l": 5.3, "horsepower": null },
        "transmission": { "summary": "Automatic, 8-speed" },
        "plant": { "city": "Fort Wayne", "state": "Indiana" },
        "safety_equipment": [
          { "label": "Curtain airbags", "value": "All Rows" },
          { "label": "Anti-lock brakes", "value": "Standard" }
        ],
        "data_source": "nhtsa_vpic"
      }
    },
    "metadata": { "credits_used": 2, "cache_hit": false }
  }
}

One call turns a VIN into the vehicle the manufacturer filed for it

A VIN on an application, a title or a listing becomes the vehicle's year, make, model and build in one call, with the raw JSON your code receives beside it. The VIN in this sample is invented.

app.1lookup.io/api/v1Found: 2019 Silverado
  • VIN1GCUYEED7KZ123456
  • FoundYes
  • Year2019
  • MakeChevrolet
  • ModelSilverado
  • TrimRST
  • Body classPickup
  • Vehicle typeTruck
  • Engine8 cylinders, 5.3 L, Gasoline
  • Drive type4WD/4-Wheel Drive/4x4
  • TransmissionAutomatic, 8-speed
  • Plant countryUnited States (USA)
  • Weight class (GVWR)Class 2F, to 8,000 lb
  • ManufacturerGeneral Motors LLC
  • Check digitMatches
200 OK, 2 credits
{
  "success": true,
  "data": {
    "classification": {
      "found": true,
      "vin": "1GCUYEED7KZ123456",
      "vehicle": "2019 Chevrolet Silverado RST",
      "body_class": "Pickup",
      "vehicle_type": "Truck",
      "engine_cylinders": 8,
      "engine_displacement_l": 5.3,
      "fuel_type": "Gasoline",
      "drive_type": "4WD/4-Wheel Drive/4x4",
      "transmission": "Automatic, 8-speed",
      "plant_country": "United States (USA)",
      "gvwr": "Class 2F: 7,001 - 8,000 lb",
      "manufacturer": "General Motors LLC",
      "check_digit_valid": true,
      "warnings": []
    },
    "metadata": { "credits_used": 2 }
  }
}

Every decoded VIN comes back with the same fields at one flat price

A field the official records leave blank comes back as null, never as a guess, and every field costs the same 2 credits.

It names the vehicle in one line and in fields

  • found
  • vin
  • vehicle
  • year
  • make
  • model
  • trim
  • series

It describes the body and the weight class

  • body_class
  • vehicle_type
  • doors
  • gvwr

It lists the engine and the drivetrain

  • engine_cylinders
  • engine_displacement_l
  • engine.horsepower
  • engine.model
  • fuel_type
  • engine.electrification
  • drive_type
  • transmission
  • transmission.speeds

It says who built the vehicle and where

  • manufacturer
  • plant_country
  • plant.city
  • plant.state
  • plant.company

It tests the VIN and warns about typos

  • check_digit_valid
  • check_digit_applies
  • vin_valid
  • warnings[]
  • suggested_vin

It lists the safety equipment the records hold

  • safety_equipment[]
  • data_source

Insurers, lenders, fleet managers and marketplaces decode VINs instead of typing specs by hand

Auto insurers fill in the vehicle from the VIN instead of asking the applicant to type it

Decode the VIN on a quote request and fill in the year, make, model, trim and body class, then compare them with what the applicant entered. A VIN that does not match the stated vehicle, or fails its check digit, is caught before the policy is priced.

Lenders and dealers confirm that the VIN on a deal matches the vehicle on the paperwork

Check the VIN on a loan application, a trade-in or a title against the year, make, model and trim the official records list for it, before funds move or the vehicle goes on the lot. A mistyped VIN comes back with a warning instead of passing through.

Fleet managers turn a column of VINs into a register of the vehicles they run

Upload a CSV of VINs and get back each vehicle's year, make, model, engine, fuel type, drive type and weight class, so a fleet register, a registration renewal or an insurance schedule starts from the records and not from memory.

Marketplaces and listing sites fill in a listing from a single VIN

A seller enters one VIN and the listing fills in the year, make, model, trim, engine and transmission. A listing whose title claims one model year while its VIN decodes to another is easy to flag before it goes live.

These are the questions people ask before they decode their first VIN

What does the VIN Decoder API return?

Send a 17-character VIN and it returns the vehicle the manufacturer filed for it: the year, make, model and trim, the body class and vehicle type, the engine's cylinders, size in litres and fuel type, the drive type, the transmission, the country where it was built, the weight class (GVWR) and the manufacturer. The full record adds the doors, the engine model and horsepower where they are filed, the transmission speeds, the plant city and state, the safety equipment on file and the check-digit result.

Where does the vehicle data come from?

From the official US vehicle records: the vPIC database run by the National Highway Traffic Safety Administration (NHTSA), where manufacturers file the build data for the vehicles they sell in the US. It is the government's own record of how each VIN was built, read when you ask. A repeat lookup of the same VIN within 7 days is served from the cache.

What does a decoded VIN tell me, and what does it leave out?

It tells you what the manufacturer filed for that VIN: the vehicle as it was built. It does not say who owns the vehicle, whether it has been in an accident, what its mileage is or whether it was ever stolen, because the official records hold none of that. Use the decode to identify and describe a vehicle, and a vehicle history service to learn what happened to it afterwards.

How much does a VIN decode cost?

2 credits per vehicle, about $0.01 on the Starter plan. You are charged only when a vehicle record comes back. A VIN the records hold nothing for, a VIN that is not 17 valid characters and a lookup the records could not answer all cost 0 credits, in the API, the dashboard and bulk jobs.

What happens when I mistype a VIN?

A VIN has exactly 17 letters and digits and never contains the letters I, O or Q. A VIN that breaks those rules cannot exist, so it is refused before anything is charged, with a message that says what is wrong, such as the position of an O that is probably a zero. Spaces and dashes are ignored and lower case is accepted, so a VIN copied off a windscreen label works as printed.

What does the check-digit warning mean?

The ninth character of a VIN is a check digit worked out from the other sixteen. For a vehicle built in the US, Canada or Mexico it must match, so a mismatch almost always means a typo. Many European and Asian VINs never used one, so a mismatch there can be normal. Either way the VIN is still decoded, and the result carries check_digit_valid, vin_valid, a plain-English entry in warnings and, when the records suggest a correction, a suggested_vin.

What happens when the records hold nothing for a VIN?

You get found: false and a message that the VIN may be mistyped or the vehicle may never have been sold in the US, with a note about the check digit when it does not match. The call succeeds and costs 0 credits. If the official records cannot be reached at all, you get a retryable 503 error instead, so an outage is never reported as a vehicle that does not exist, and that costs nothing either.

Can I decode a list of VINs at once?

Yes. Upload a CSV with a vin column and you get a row per vehicle with the year, make, model, trim, body class, engine, drive type, transmission, plant country, weight class, manufacturer, a Found column and the check-digit result. A row that is not a valid VIN fails without a charge. The price stays at 2 credits per vehicle found, however long the list is.

Which vehicles does it cover?

Vehicles built for the US market, such as cars, trucks, buses, motorcycles and trailers whose manufacturers filed them with NHTSA. A vehicle built before the 17-character VIN became the standard in 1981 is not covered, and an older or imported vehicle can have a partial record. A field the records do not hold comes back as null, never as a guess.

Can I try it on one VIN before I use the API?

Yes. The free VIN decoder on 1Lookup decodes one VIN at a time with no account, reading the same official records. Use the API when you need to decode vehicles inside your own application, an intake form or a list.

To decode a single VIN before you write any code, use the free VIN decoder.

Decode a few of your own VINs and see what comes back

Start a free trial, and your credits work across every product in the catalog.