Luhn Algorithm Test: How the Mod 10 Check Works

The Luhn algorithm test checks whether a string of digits has a valid format. It doubles every second digit from the right, adds all the digits together, and passes the number when the total is a multiple of 10. It catches typos and most swapped digits, but it says nothing about whether the card, account, or device behind that number exists.

What does the Luhn algorithm test check?

Luhn is a checksum, also called a modulus 10 or mod 10 check. The last digit of the number is a check digit calculated from every digit before it. Change one digit anywhere in the string and the sum stops dividing by 10.

IBM engineer Hans Peter Luhn filed the patent in 1954, and the method spread into banking, telecom, and government numbering systems. It was built for keypunch operators typing long numbers into cards, where a single mistyped digit caused real damage.

• Catches: any single wrong digit.
• Catches: most swaps of two neighboring digits.
• Misses: the pairs 09 and 90, which swap without changing the sum.
• Misses: two-digit errors such as 22 typed as 55.

How do you run a Luhn check by hand?

1. Write the digits in order and ignore spaces or dashes.
2. Starting from the rightmost digit, count positions. Leave the first digit (the check digit) alone.
3. Double the value of every digit in an even position counting from the right.
4. If a doubled value is 10 or more, subtract 9 from it. That keeps the result a single digit.
5. Add the untouched digits and the doubled digits together.
6. The number is valid when the total ends in 0.

Worked example with 79927398713

Reading right to left, the digits in even positions are 1, 8, 3, 2 and 9. Doubling gives 2, 16, 6, 4 and 18. After subtracting 9 from the two large values, they become 7 and 9.

The doubled column adds to 2 + 7 + 6 + 4 + 9 = 28. The digits left alone (3, 7, 9, 7, 9, 7) add to 42. The total is 70, which is 7 × 10, so 79927398713 passes.

Now change the 8 to a 5. The sum moves by 7 and lands on 63. The check fails at once.

Which numbers use the Luhn check?

• Payment card numbers built on the ISO/IEC 7812 numbering scheme.
• IMEI numbers on mobile phones.
• Canadian Social Insurance Numbers.
• Greek VAT identification numbers and several other national tax IDs.
• Some loyalty cards, library cards, and transit passes.

Card issuers rely on it because it stops most accidental keystroke errors before a request ever reaches the network. That is the whole purpose. It is a typing filter, not a gate.

Does a passing Luhn test mean a card is real?

No. A number that passes the Luhn check is a number that is spelled correctly. Nothing more.

A valid checksum can sit on a closed account, a canceled card, an expired card, or a number someone invented. Authorization, balance, address verification, and fraud screening all happen elsewhere. The Luhn digit carries no identity, no bank code, and no balance.

This is why a checksum pass is weak evidence on its own. It proves format. It does not prove life.

How do you code a Luhn check?

Treat the input as a string, not an integer. Long card numbers overflow 32-bit types and lose digits when converted.

Python

def luhn_ok(number):
    digits = [int(d) for d in str(number) if d.isdigit()]
    total = 0
    for i, d in enumerate(reversed(digits)):
        if i % 2 == 1:
            d *= 2
            if d > 9:
                d -= 9
        total += d
    return total % 10 == 0

JavaScript

function luhnOk(value) {
  const digits = String(value).replace(/\D/g, '');
  let total = 0;
  for (let i = 0; i < digits.length; i++) {
    let d = Number(digits[digits.length - 1 - i]);
    if (i % 2 === 1) { d *= 2; if (d > 9) d -= 9; }
    total += d;
  }
  return total % 10 === 0;
}

What mistakes break a Luhn implementation?

• Doubling from the left instead of the right. The parity flips when the length changes.
• Forgetting the subtract-9 rule, so 16 stays 16 and the sum runs high.
• Double-counting the check digit as if it were a normal digit.
• Stripping leading zeros during a numeric conversion.
• Testing a single card brand instead of the general case. All of them follow the same rule.

Frequently asked questions

Is the Luhn algorithm the same as a mod 10 check?

Yes. Luhn is the best-known mod 10 checksum, and the terms are used as synonyms. Other mod 10 schemes exist with different weightings, so name the algorithm when precision matters.

Can the Luhn test detect every error?

No checksum can. Luhn handles single-digit slips and most transpositions but allows the 09 and 90 swap and some two-digit mistakes. Its error detection rate sits near 98% for realistic typing errors.

Why do so many random numbers pass?

One in ten strings passes by chance, because the final digit is free to be anything from 0 to 9. With four billion 16-digit combinations, roughly 400 million pass the check. That is why the test filters typos and nothing else.

Does the Luhn check apply to CVV codes?

No. Three- and four-digit security codes are short, and adding a checksum digit would leave too few digits to carry useful data. They are validated against the issuer's records instead.

Is a Luhn validation a security feature?

No. It is an input validation step that catches typing mistakes. Anyone can compute the check digit for any prefix, so the algorithm offers zero protection against invented numbers.