Home Blog

Random VIN Number: Valid vs Real, Tested on 120 VINs [2026]

Random VIN Number: Valid vs Real, Tested on 120 VINs [2026]

Last updated: October 31, 2026

You need a VIN for a test. You type 17 random letters and numbers, hit submit, and your form says it is invalid.

That is not bad luck. In a test we ran on 200,000 random 17-character strings, only 3.00% passed the VIN check digit. The other 97% failed on the math alone.

So you reach for a random VIN generator. But here is the part most guides skip: not every “valid” random VIN is the same. We decoded 120 of them with the US government’s NHTSA vehicle database to see what each kind really does.

Why does a made-up VIN fail?

A VIN has a check digit in position 9. It comes from a small calculation on the other 16 characters. Change one character and the check digit no longer matches. A random string only lines up by chance, about 3 times in 100.

Two other rules trip up random strings:

  • The letters I, O and Q are never used, because they look like 1 and 0.
  • Position 10 is a model-year code, and the first three characters are a maker code. Random letters there rarely mean anything.

Quick Tip: If you only need to test that your input field accepts a correct VIN, a VIN with a valid check digit is enough. If your app also looks up the car, you need more. Read on.

Random, valid and real: what do these words mean?

People use them loosely, so we split them into three tests:

  • Valid: passes the length, the character rules and the check digit math.
  • Decodes: a vehicle database recognises it and returns a make and a model.
  • Real: belongs to an actual car that exists. A generator should never give you one of these on purpose.

We tested three kinds of random VIN

We made 40 VINs of each kind, gave all of them a correct check digit, and ran every one through the NHTSA vPIC decoder. A VIN “decodes to a vehicle” when NHTSA returns both a make and a model with no errors. We ignored one harmless note that some detail is missing.

Kind of VIN Decodes to a vehicle Maker only Nothing
Random characters, valid check digit 0 of 40 5 35
Real maker code, random rest, valid check digit 0 of 40 31 9
Our make and model data 40 of 40 0 0

The first two kinds pass any check digit test. Neither one decoded to a single vehicle. Random characters were mostly unknown to NHTSA, and a real maker code with random characters after it was recognised as a brand, but never as a model.

The last row is no surprise, because we found those patterns by testing NHTSA’s public decoder and kept only the ones it recognised. It is also why it works: the first eight characters belong to a real model, the year and plant codes match, and only the serial number is random.

Warning: This was a small test, 40 VINs per kind, against US data. Non-US VINs and very new models may behave differently. Treat the numbers as a clear direction, not a guarantee.

So which random VIN should you use?

It depends on what your test does.

Your test What you need Tool
A form accepts or rejects a VIN Valid length, characters and check digit Any generator
Your app decodes a VIN and shows make and model A VIN that decodes to a real model Random VIN Generator
You need a specific car, such as a 2022 Camry A VIN for that year, make and model VIN generator by year, make and model
You need hundreds of rows of test data Many decodable VINs at once Bulk VIN Generator

The bulk generator used to make only random characters with a valid check digit, which our test shows will not decode. We changed it to use the same make and model data as the main generator. We then decoded a sample of its output with NHTSA, and all 12 came back as real models.

How to generate a valid VIN in code

If you want to build your own, the check digit is short. This Python function returns the correct ninth character, and the second function checks a whole VIN:

VALUES = {**{str(i): i for i in range(10)},
          **dict(zip("ABCDEFGH", range(1, 9))),
          **dict(zip("JKLMN", range(1, 6))),
          "P": 7, "R": 9,
          **dict(zip("STUVWXYZ", range(2, 10)))}
WEIGHTS = [8, 7, 6, 5, 4, 3, 2, 10, 0, 9, 8, 7, 6, 5, 4, 3, 2]

def check_digit(vin):
    total = sum(VALUES[c] * w for c, w in zip(vin, WEIGHTS))
    r = total % 11
    return "X" if r == 10 else str(r)

def is_valid(vin):
    return len(vin) == 17 and vin[8] == check_digit(vin)

We ran this on 4T1B61BKXNU123456. It returns True. Change the ninth character to 1 and it returns False.

The check digit is the easy part. Making a VIN that decodes to a real model needs real model patterns, which is the hard part. That is the gap our tools fill.

Quick Tip: Check your own test VINs with the VIN Validator and the VIN Decoder. The Check Digit Calculator shows every step of the math.

Can I get a “real” random VIN?

You can get one that decodes to a real model, such as a 2022 Toyota Camry. You cannot, and should not, get one that belongs to a real car that someone owns. Our serial numbers are random, so a generated VIN is not tied to a registered vehicle.

A random chance match with a real car is not impossible, which is one more reason to keep generated VINs in test environments only.

Use them for testing only

A generated VIN is for software tests, demos and learning. Never use one for a registration, insurance, a title, a sale or a listing. Using a made-up VIN to misrepresent a car is illegal, and it is the first thing any serious buyer will check. If you are checking a real used car, start with how to check if a VIN is valid.

For official vehicle data, the NHTSA vPIC service we used for this test is public. You can read how it works at vpic.nhtsa.dot.gov/api.

Frequently Asked Questions

Are random VINs valid?

They can be. A good generator calculates the check digit and avoids the letters I, O and Q, so the VIN passes validation. Passing validation does not mean it decodes to a vehicle. In our test, VINs with random characters and a valid check digit decoded to no vehicle at all.

Why does my random VIN not decode?

Because the first eight characters do not match any real model. The maker code, model pattern and year all have to line up. A generator that uses real model data fixes this.

For testing, development and demos, yes. For anything that represents a real vehicle, no. Never use a generated VIN on a registration, insurance policy, title or sale.

Keep Reading

← Back to all articles