Check Digit Calculator: GS1, UPC, ISBN and Luhn

Calculate a check digit online for free. Choose the number or barcode type, such as a UPC, EAN-13, SSCC, ISBN-10, Code 128 or a Luhn number like an IMEI, type the digits, and see the check digit with every step of the sum. Verify mode tests a full number.

Calculated

5901234123457

Number

Number or barcode type

Number without the check digit12 characters

12 digits without the check digit.

Mode

Calculate the check for a number without it.

The algorithm as codeTypeScript

package checkdigit

// Code128Check returns the check value: (start value + Σ position × codeword value) mod 103.
func Code128Check(codewords []int) int {
	sum := codewords[0]
	for i := 1; i < len(codewords); i++ {
		sum += codewords[i] * i
	}
	return sum % 103
}

<?php
/** Code 128 check value: (start value + Σ position × codeword value) mod 103. */
function code128Check(array $codewords): int
{
    $sum = $codewords[0];
    for ($i = 1; $i < count($codewords); $i++) {
        $sum += $codewords[$i] * $i;
    }
    return $sum % 103;
}

def code128_check(codewords: list[int]) -> int:
    """Code 128 check value: (start value + sum of position x codeword value) mod 103."""
    return (codewords[0] + sum(i * v for i, v in enumerate(codewords) if i > 0)) % 103

/** Code 128 check value: (start value + Σ position × codeword value) mod 103. */
export function code128Check(codewords: number[]): number {
  let sum = codewords[0]!;
  for (let i = 1; i < codewords.length; i++) sum += codewords[i]! * i;
  return sum % 103;
}

package checkdigit

import "strings"

const code39Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%"

// Code39Check returns the Code 39 mod 43 check character: the sum of the character values, modulo 43.
func Code39Check(data string) string {
	sum := 0
	for _, ch := range data {
		sum += strings.IndexRune(code39Chars, ch)
	}
	return string(code39Chars[sum%43])
}

<?php
const CODE39 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';

/** Code 39 mod 43 check character: the sum of the character values, modulo 43. */
function code39Check(string $data): string
{
    $sum = 0;
    foreach (str_split($data) as $ch) {
        $sum += strpos(CODE39, $ch);
    }
    return CODE39[$sum % 43];
}

CODE39 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%"


def code39_check(data: str) -> str:
    """Code 39 mod 43 check character: the sum of the character values, modulo 43."""
    return CODE39[sum(CODE39.index(ch) for ch in data) % 43]

const CODE39 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';

/** Code 39 mod 43 check character: the sum of the character values, modulo 43. */
export function code39Check(data: string): string {
  let sum = 0;
  for (const ch of data) sum += CODE39.indexOf(ch);
  return CODE39[sum % 43]!;
}

package checkdigit

import "strings"

const code93Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%"

func code93Weighted(values []int, limit int) int {
	sum := 0
	for i, v := range values {
		sum += v * ((len(values)-1-i)%limit + 1)
	}
	return sum % 47
}

// Code93Checks returns the check values C and K (0–46; 43–46 are the shift characters ($) (%) (/) (+)).
func Code93Checks(data string) (int, int) {
	values := make([]int, 0, len(data)+1)
	for _, ch := range data {
		values = append(values, strings.IndexRune(code93Chars, ch))
	}
	c := code93Weighted(values, 20)
	k := code93Weighted(append(values, c), 15)
	return c, k
}

<?php
const CODE93 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';

function code93Weighted(array $values, int $limit): int
{
    $sum = 0;
    $n = count($values);
    foreach ($values as $i => $value) {
        $sum += $value * (($n - 1 - $i) % $limit + 1);
    }
    return $sum % 47;
}

/** Code 93 check values C and K (0–46; 43–46 are the shift characters ($) (%) (/) (+)). */
function code93Checks(string $data): array
{
    $values = array_map(fn ($ch) => strpos(CODE93, $ch), str_split($data));
    $c = code93Weighted($values, 20);
    $k = code93Weighted([...$values, $c], 15);
    return [$c, $k];
}

CODE93 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%"


def code93_checks(data: str) -> tuple[int, int]:
    """Code 93 check values C and K (0-46; 43-46 are the shift characters ($) (%) (/) (+))."""
    def weighted(values: list[int], limit: int) -> int:
        n = len(values)
        return sum(v * ((n - 1 - i) % limit + 1) for i, v in enumerate(values)) % 47

    values = [CODE93.index(ch) for ch in data]
    c = weighted(values, 20)
    k = weighted(values + [c], 15)
    return c, k

const CODE93 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%';

/** Code 93 check values C and K (0–46; 43–46 are the shift characters ($) (%) (/) (+)). */
export function code93Checks(data: string): [number, number] {
  const values = [...data].map((ch) => CODE93.indexOf(ch));
  const weighted = (list: number[], limit: number) =>
    list.reduce((sum, value, i) => sum + value * (((list.length - 1 - i) % limit) + 1), 0) % 47;
  const c = weighted(values, 20);
  const k = weighted([...values, c], 15);
  return [c, k];
}

package checkdigit

// GS1CheckDigit returns the GS1 mod 10 check digit: weights 3 and 1 from the right (GTIN, SSCC, GLN).
func GS1CheckDigit(body string) int {
	sum := 0
	for i := 0; i < len(body); i++ {
		digit := int(body[len(body)-1-i] - '0')
		if i%2 == 0 {
			sum += digit * 3
		} else {
			sum += digit
		}
	}
	return (10 - sum%10) % 10
}

<?php
/** GS1 mod 10 check digit: weights 3 and 1 from the right (GTIN, SSCC, GLN). */
function gs1CheckDigit(string $body): int
{
    $sum = 0;
    $length = strlen($body);
    for ($i = 0; $i < $length; $i++) {
        $digit = (int) $body[$length - 1 - $i];
        $sum += $i % 2 === 0 ? $digit * 3 : $digit;
    }
    return (10 - $sum % 10) % 10;
}

def gs1_check_digit(body: str) -> int:
    """GS1 mod 10 check digit: weights 3 and 1 from the right (GTIN, SSCC, GLN)."""
    total = 0
    for i, ch in enumerate(reversed(body)):
        total += int(ch) * (3 if i % 2 == 0 else 1)
    return (10 - total % 10) % 10

/** GS1 mod 10 check digit: weights 3 and 1 from the right (GTIN, SSCC, GLN). */
export function gs1CheckDigit(body: string): number {
  let sum = 0;
  for (let i = 0; i < body.length; i++) {
    const weight = (body.length - 1 - i) % 2 === 0 ? 3 : 1;
    sum += Number(body[i]) * weight;
  }
  return (10 - (sum % 10)) % 10;
}

package checkdigit

// LuhnCheckDigit returns the Luhn check digit: from the right, double every second digit
// starting next to the check, and add the digits.
func LuhnCheckDigit(body string) int {
	sum := 0
	for i := 0; i < len(body); i++ {
		digit := int(body[len(body)-1-i] - '0')
		if i%2 == 0 {
			digit *= 2
			if digit > 9 {
				digit -= 9
			}
		}
		sum += digit
	}
	return (10 - sum%10) % 10
}

<?php
/** Luhn check digit: from the right, double every second digit starting next to the check, add the digits. */
function luhnCheckDigit(string $body): int
{
    $sum = 0;
    $length = strlen($body);
    for ($i = 0; $i < $length; $i++) {
        $digit = (int) $body[$length - 1 - $i];
        if ($i % 2 === 0) {
            $digit *= 2;
            if ($digit > 9) {
                $digit -= 9;
            }
        }
        $sum += $digit;
    }
    return (10 - $sum % 10) % 10;
}

def luhn_check_digit(body: str) -> int:
    """Luhn check digit: from the right, double every second digit starting next to the check, add the digits."""
    total = 0
    for i, ch in enumerate(reversed(body)):
        digit = int(ch)
        if i % 2 == 0:
            digit *= 2
            if digit > 9:
                digit -= 9
        total += digit
    return (10 - total % 10) % 10

/** Luhn check digit: from the right, double every second digit starting next to the check, add the digits. */
export function luhnCheckDigit(body: string): number {
  let sum = 0;
  for (let i = 0; i < body.length; i++) {
    let digit = Number(body[body.length - 1 - i]);
    if (i % 2 === 0) {
      digit *= 2;
      if (digit > 9) digit -= 9;
    }
    sum += digit;
  }
  return (10 - (sum % 10)) % 10;
}

package checkdigit

import "strconv"

// Mod11Check returns the check character for ISBN-10 (9 digits) or ISSN (7 digits):
// weights from length + 1 down to 2; 10 is written X.
func Mod11Check(body string) string {
	sum := 0
	for i := 0; i < len(body); i++ {
		sum += int(body[i]-'0') * (len(body) + 1 - i)
	}
	check := (11 - sum%11) % 11
	if check == 10 {
		return "X"
	}
	return strconv.Itoa(check)
}

<?php
/** Mod 11 check character for ISBN-10 (9 digits) or ISSN (7 digits): weights from length + 1 down to 2; 10 is X. */
function mod11Check(string $body): string
{
    $sum = 0;
    $length = strlen($body);
    for ($i = 0; $i < $length; $i++) {
        $sum += (int) $body[$i] * ($length + 1 - $i);
    }
    $check = (11 - $sum % 11) % 11;
    return $check === 10 ? 'X' : (string) $check;
}

def mod11_check(body: str) -> str:
    """Mod 11 check character for ISBN-10 (9 digits) or ISSN (7 digits): weights from length + 1 down to 2; 10 is X."""
    total = sum(int(ch) * (len(body) + 1 - i) for i, ch in enumerate(body))
    check = (11 - total % 11) % 11
    return "X" if check == 10 else str(check)

/** Mod 11 check character for ISBN-10 (9 digits) or ISSN (7 digits): weights from length + 1 down to 2; 10 is X. */
export function mod11Check(body: string): string {
  let sum = 0;
  for (let i = 0; i < body.length; i++) sum += Number(body[i]) * (body.length + 1 - i);
  const check = (11 - (sum % 11)) % 11;
  return check === 10 ? 'X' : String(check);
}

Each snippet is run in its language against the examples and 200 random inputs that this calculator is tested with.

EAN-13 / GTIN-13 · ResultCalculated

Check digit

5901234123457

Make the barcode

Type: EAN-13 / GTIN-13
Algorithm: GS1 mod 10, weights 3 and 1
Characters: 12 + check
Check digit: 7

Steps

How the check is calculated
#	Character	Value	Weight	Product
1	5	5	×1	5
2	9	9	×3	27
3	0	0	×1	0
4	1	1	×3	3
5	2	2	×1	2
6	3	3	×3	9
7	4	4	×1	4
8	1	1	×3	3
9	2	2	×1	2
10	3	3	×3	9
11	4	4	×1	4
12	5	5	×3	15
Sum				83

Nearest multiple of ten at or above 83 is 90: 90 − 83 = 7

How to Calculate a Check Digit

Choose the type, type the number without its check digit, and read the result with the steps that lead to it.

Choose the number or barcode type, such as EAN-13, SSCC, ISBN-10 or Code 128.
Type the number or data without its check digit; spaces and hyphens in numbers are ignored.
Read the check digit and the full number in the result, copy them, and follow each step in the Steps card below.
To test a number you already have, switch to Verify and enter it with its check digit: the badge says Valid or Invalid and shows the right check.
For EAN-13, UPC-A, EAN-8, GTIN-14, SSCC, ISBN-10, Code 93 and Code 128, choose Make the barcode to open the generator with the same type and number.

Check Digit Types This Calculator Supports

The calculator covers the GS1 numbers on retail and logistics barcodes, ISBN-10 and ISSN, the check characters of Code 39, Code 93 and Code 128, and Luhn numbers.

GS1 Numbers: GTIN, UPC, EAN and SSCC

EAN-13 / GTIN-13: 12 digits, then the check digit; a 13-digit GLN works the same way.
UPC-A / GTIN-12: 11 digits, then the check digit.
EAN-8 / GTIN-8: 7 digits, then the check digit.
GTIN-14 / ITF-14: 13 digits, then the check digit.
SSCC: 17 digits, then the check digit, as in GS1's own example.
Any length: the same GS1 rule for other numbers, such as an Interleaved 2 of 5 check digit.

ISBN-10 and ISSN

ISBN-10: 9 digits, then a check character from 0 to 9 or X.
ISSN: 7 digits, then a check character from 0 to 9 or X.

Barcode Check Characters

Code 39: an optional mod 43 check character, one of the 43 Code 39 characters.
Code 93: two check characters, C and K, which every Code 93 barcode carries.
Code 128: a check value from 0 to 102 over the codewords, which every Code 128 barcode carries.

Luhn Numbers

IMEI: the first 14 digits of a phone's IMEI, then the Luhn check digit (3GPP TS 23.003).
Payment card numbers: the same Luhn check, defined in ISO/IEC 7812; the calculator only does the arithmetic.

What Is a Check Digit?

A check digit is a digit calculated from the other digits of a number and added to it, so that a typing or reading error can be spotted.

What a Check Digit Catches

Every algorithm on this page detects a single wrong digit or character, wherever it is. The tests check this for every position and every pair of digits. The mod 11 check of ISBN-10 and ISSN also detects every swap of two neighboring digits.

What a Check Digit Misses

GS1 mod 10 misses a swap of neighboring digits that differ by 5, such as 16 and 61, and Luhn misses only a swap of 09 and 90. Code 39 adds the character values without weights, so it misses every swap. Two wrong digits can also cancel out, so a valid check digit does not prove that a number is right.

A Valid Check Digit Is Not a Registration

A GTIN with a correct check digit can still be unassigned or belong to someone else, because the check only tests the arithmetic. GTINs come from a GS1 Company Prefix or a GTIN licensed by GS1. The barcode lookup shows which GS1 office issued a number's prefix.

Check Digit Algorithm Comparison

The algorithms differ in their weights and modulus, and so in the errors they catch; this table compares them as this calculator implements them.

Check digit algorithms compared
Algorithm	Used in	Weights	Modulus	Swaps of neighbors caught
GS1 mod 10	GTIN, UPC, EAN, SSCC, GLN, ITF	3 and 1 from the right	10	All except digits that differ by 5
Luhn	IMEI, payment card numbers	2 and 1 from the right, digits of each product added	10	All except 09 and 90
Mod 11	ISBN-10, ISSN	10 to 2, or 8 to 2	11 (10 is written X)	All
Mod 43	Code 39 (optional)	None: values are added	43	None
Mod 47 (C and K)	Code 93	1 to 20 and 1 to 15 from the right	47	All
Mod 103	Code 128	Start 1, then the position	103	All swaps of neighboring codewords

GS1 Check Digit Example

GS1's General Specifications work the 17 digits 37610425002123456 through to the check digit 9; this calculator shows the same steps for the SSCC type.

Multiply the digits by 3 and 1 in turn, starting with 3 on the rightmost digit: 3×3, 7×1, 6×3 and so on.
Add the products: 9 + 7 + 18 + 1 + 0 + 4 + 6 + 5 + 0 + 0 + 6 + 1 + 6 + 3 + 12 + 5 + 18 = 101.
Subtract the sum from the nearest equal or higher multiple of ten: 110 − 101 = 9.
Write the check digit last: 376104250021234569.

How the UPC check digit works the same rule worked through for a 12-digit UPC-A.

How to calculate a GTIN check digit the rule for every GTIN length.

Luhn Check Digit Example

The Luhn check doubles every second digit from the right, adds the digits, and picks the check digit that brings the total to a multiple of ten.

Take the 14 digits of the IMEI example in 3GPP TS 23.003: 26053179311383.
From the right, double every second digit, starting with the digit next to the check: 3, 3, 1, 9, 1, 5 and 6 become 6, 6, 2, 18, 2, 10 and 12.
Add all the digits, counting 18 as 1 + 8, 10 as 1 + 0 and 12 as 1 + 2: the total is 53.
Subtract from the next multiple of ten: 60 − 53 = 7, so the full IMEI is 260531793113837.

Check Digit Code in TypeScript, Python, Go and PHP

The fold The algorithm as code, under the number, shows the selected algorithm as a short function in TypeScript, Python, Go or PHP, ready to copy.

Each function is run in its own language against the published examples and 200 random inputs per algorithm, and must return exactly what the calculator returns. A language this site cannot run is not offered, so there is no Rust, C# or Java version.

Frequently Asked Questions

Is the Check Digit Part of the Barcode Number?

Yes, for GTINs, ISBNs and ISSNs: it is the last digit, printed under the barcode and returned by a scanner. Code 128 and Code 93 check characters are different, as they sit only in the bars and a scanner removes them after checking.

Why Is the ISBN-10 Check Character Sometimes X?

The ISBN-10 check uses modulus 11, so it can come out as 10, which does not fit in one digit. It is written as the letter X, as in 1-56581-231-X. ISBN-13 uses the GS1 mod 10 rule and never needs an X.

How Do I Check If a Barcode Number Is Valid?

Choose its type, switch to Verify and enter the whole number, check digit included. The calculator says whether the last digit is right, and if not, which digit it should be.

Can I Check a Credit Card Number With the Luhn Check?

Verify with the Luhn type tells you whether the last digit fits the others, which catches most typing errors. It cannot tell whether a card exists or is valid for payment. The number is not sent anywhere: the calculation runs in your browser.

Is a Mod 10 Check Digit Always the Same?

No. GS1 numbers and Luhn numbers both use modulus 10, but with different weights, so the same digits can give different check digits. For 26053179311383, Luhn gives 7 and the GS1 rule gives 2.

Can a Check Digit Correct an Error?

No. It shows that something is wrong but not which digit, so the number has to be read or typed again. Error correction, which can repair damage, is a feature of 2D codes such as QR Code and Data Matrix.

Barcode lookup
Check a UPC, EAN or ISBN and see the GS1 office behind its prefix.
SSCC barcode generator
The 18-digit SSCC with its check digit, as a GS1-128 barcode.
Barcode generator
Make the barcode once the number is right.

#	Character	Value	Weight	Product
1	5	5	×1	5
2	9	9	×3	27
3	0	0	×1	0
4	1	1	×3	3
5	2	2	×1	2
6	3	3	×3	9
7	4	4	×1	4
8	1	1	×3	3
9	2	2	×1	2
10	3	3	×3	9
11	4	4	×1	4
12	5	5	×3	15
Sum				83

#	Character	Value	Weight	Product
1	5	5	×1	5
2	9	9	×3	27
3	0	0	×1	0
4	1	1	×3	3
5	2	2	×1	2
6	3	3	×3	9
7	4	4	×1	4
8	1	1	×3	3
9	2	2	×1	2
10	3	3	×3	9
11	4	4	×1	4
12	5	5	×3	15
Sum				83