Validate a Number
Generate a Valid Luhn Number
Examples
Luhn Algorithm Checker validates numbers using the Luhn algorithm (Mod 10 algorithm) — the checksum formula used to validate credit card numbers, IMEI numbers, Canadian Social Insurance Numbers, and other identification numbers. Enter any number to check if it passes the Luhn check, see the calculation step by step, or generate valid test card numbers for development.
The Luhn algorithm was created by IBM scientist Hans Peter Luhn in 1954 and patented in 1960. It's a simple checksum formula that detects accidental errors in digit sequences — specifically single-digit errors and transpositions of adjacent digits. The algorithm: starting from the rightmost digit (check digit), double every second digit, subtract 9 if the doubled value exceeds 9, sum all digits, and verify the total is divisible by 10.
The Luhn check is not a security mechanism — it only detects accidental errors (typos), not deliberate fraud. A credit card number that passes Luhn is not necessarily a real card number. Test card numbers (4111111111111111, 5500005555555550) are valid Luhn-passing numbers that payment processors recognize as test cards. Never use real card numbers in development or testing — always use official test numbers from your payment provider (Stripe, PayPal, etc.).
Validate Visa test number
Result: 4111111111111111 → Sum=40 → 40 mod 10 = 0 → ✓ Valid Luhn checksum
Invalid number
Result: 4111111111111112 → Sum=41 → 41 mod 10 ≠ 0 → ✗ Invalid Luhn checksum
IMEI validation
Result: Enter 15-digit IMEI → Luhn validation → confirms the IMEI format is structurally valid
What is the Luhn algorithm and how does it work?
The Luhn algorithm (step by step): (1) Starting from the check digit (rightmost), moving left, double every second digit. (2) If doubling produces a number > 9, subtract 9 (e.g., 8 × 2 = 16 → 16 - 9 = 7). This is equivalent to adding the digits of the doubled value (1+6=7). (3) Sum all the digits. (4) If the total modulo 10 equals 0, the number is valid. Example: 4532015112830366. The algorithm detects: any single-digit transposition error (swapping adjacent digits), most adjacent transposition errors, and all single-digit substitution errors.
What numbers use the Luhn algorithm?
Major uses of the Luhn check: Credit/debit cards (all major networks: Visa, Mastercard, Amex, Discover). IMEI numbers (15-digit mobile phone identifiers). Canadian Social Insurance Numbers (SIN). Israel ID numbers. Some ICCID numbers (SIM card identifiers). CUSIP numbers (US stock identifiers, uses a modified version). National Provider Identifiers (NPI, US healthcare providers). Gift card numbers from many retailers. The algorithm is not used for: US Social Security Numbers (SSNs have no checksum), most bank account numbers (which use other validation methods), or passport numbers.
What are standard test credit card numbers for development?
Official test card numbers that pass Luhn (safe for development — never real cards): Visa: 4111111111111111, 4012888888881881. Mastercard: 5500005555555550, 5105105105105100. Amex: 378282246310005, 371449635398431. Discover: 6011111111111117. These are officially documented test numbers recognized by payment processors as sandbox/test cards. Stripe-specific: 4242424242424242 (Visa success), 4000000000000002 (card declined). Always use payment provider-specific test numbers — don't generate your own.
Does passing the Luhn check mean a credit card is real?
No — Luhn validation only checks the mathematical checksum structure. A Luhn-valid number could be: a real credit card number, an expired card number, a cancelled card number, a generated-but-never-issued number. Luhn validation is useful for: catching typos before submitting to payment processors (saves an API call), client-side form validation, generating valid-looking test numbers. For actual payment validation, you must submit to a payment processor (Stripe, PayPal) which checks: card existence, expiration, CVV, fraud signals, and available balance.
How do I implement the Luhn algorithm in code?
JavaScript: function luhn(n) { return [...n.toString()].reverse().reduce((sum, d, i) => { let v = +d; if (i % 2 === 1) { v *= 2; if (v > 9) v -= 9; } return sum + v; }, 0) % 10 === 0; }. Python: def luhn(n): digits = [int(d) for d in str(n)[::-1]]; return sum(d if i%2==0 else (d*2-9 if d*2>9 else d*2) for i,d in enumerate(digits)) % 10 == 0. Most major languages have Luhn validator libraries. For production payment processing, use your payment provider's SDK rather than implementing card validation yourself.