How Check Digits Work: The Math Behind GTIN, ISBN and SSCC

The short answer

A check digit is the last digit of an identifier, computed from the preceding digits by a fixed formula. UPC-A, EAN-13, GTIN-8/12/13/14, ISBN-13 and SSCC all use the same GS1 mod-10 algorithm. ISBN-10 uses an older mod-11 variant that introduces X as a check character. Code 128 carries an internal modulo-103 checksum that's invisible in the decoded payload — only relevant when you're generating the symbol itself.

GS1 mod-10: the math walkthrough

Take the worked example that runs through this site's guides: GTIN-13 5012345678900. The first twelve digits are the body; the last digit is the check.

1. Take the body. Strip the trailing check digit, leaving 501234567890.
2. Read right-to-left, alternating weights of 3 and 1, starting with 3. For 501234567890:

   Body (reversed): 0  9  8  7  6  5  4  3  2  1  0  5
   Weights:         3  1  3  1  3  1  3  1  3  1  3  1
   Products:        0  9 24  7 18  5 12  3  6  1  0  5
   Sum:             0+9+24+7+18+5+12+3+6+1+0+5 = 90

3. The check digit is whatever brings the sum to the next multiple of 10. 90 is already a multiple of 10, so the check digit is 0. Append to the body and you have the full GTIN-13: 5012345678900.

The calculator runs this same algorithm for any GTIN body — useful when you're minting new identifiers from a fresh company prefix:

To verify the complete identifier in one step (length class plus check digit) feed it to the validator:

Why mod-10 catches typos and transpositions

Mod-10 isn't a cryptographic hash — it's a deliberately cheap algorithm that catches the most common human errors with one digit of address-space tax. Two properties make it useful:

• Every single-digit error is caught. Change any one digit of the body by 1, the sum changes by either 1 or 3, and the resulting check digit moves with it. Mismatch → flagged.
• Most adjacent transpositions are caught. Swap two neighbouring digits and the sum changes by 2×(difference between them). Whenever that difference is anything other than 0 or 5, the check digit moves and the typo is caught. The blind spot — swapping a 0 and a 5, or a 1 and a 6 — accounts for about 5% of transpositions.

In practice, mod-10 catches the entire class of single-digit typos and the vast majority of transpositions — together that's about 90% of real-world data entry mistakes. The math is from a 1954 paper by Hans Peter Luhn at IBM; the formula has been the GS1 default since GS1 existed.

ISBN-10's mod-11 variant

ISBN-10 — the old ten-digit book identifier — uses a different algorithm. Same spirit (a trailing check digit), different math.

1. Take the body — the first nine digits of the ISBN-10.
2. Read left-to-right and multiply each digit by a descending weight starting at 10:

   Body (left-to-right): 0  1  4  3  0  3  3  4  4
   Weights:              10 9  8  7  6  5  4  3  2
   Products:              0  9 32 21  0 15 12 12  8
   Sum:                   0+9+32+21+0+15+12+12+8 = 109

3. The check digit is whatever brings the sum to the next multiple of 11. 109 → next multiple of 11 is 110, so the check digit is 1. Full ISBN-10: 0143033441.

Most book systems today carry ISBN-13 alongside the legacy ISBN-10; the ISBN reader on this site validates both and surfaces whichever your input started from.

Code 128's modulo-103 checksum

Code 128 (and its GS1-128 cousin) carries an internal checksum that uses modulo-103 — the symbology has 103 codeword positions, so the weights and the modulus both run to that. The checksum is appended as an extra codeword inside the bar pattern; it's never part of the decoded payload.

For most readers and developers, the practical takeaway is short: Code 128 has its own check digit, you don't compute it, you don't see it, and it's why a scratched Code 128 either reads correctly or doesn't read at all. For the spec-level walkthrough of subsets and FNC1, see the Code 128 explained guide.

Common mistakes

• Recomputing the check digit and overwriting the supplier's value. If the supplied check doesn't match, the right action is to flag the row for human review — not to silently rewrite the digit. The original input might be the source of truth.
• Using the wrong algorithm. ISBN-10 input fed into a GS1 mod-10 validator returns garbage; an ISBN-13 fed into a mod-11 validator does the same. Route inputs to the correct algorithm based on length and prefix.
• Storing the check digit separately from the body. Some legacy systems split GTIN into "body" and "check" columns. That makes it too easy to re-concatenate them in the wrong order. Store the complete identifier as a single string.
• Skipping validation on internal SKUs. If your internal codes happen to be 12 or 13 digits, they'll look like GTINs but won't validate. Either give them an obviously non-GTIN format, or add a check digit of your own.
• Assuming a valid check digit means the GTIN exists. Mod-10 checks the math; it doesn't confirm the identifier was issued to a real company by GS1. For ownership verification you need GS1 Verified-by-GS1, not a local check.

References

• GS1 General Specifications — defines the mod-10 algorithm for every GS1 identifier. Published by GS1 and updated annually.
• ISO 2108 (ISBN) — the international standard that defines ISBN-10 (mod-11) and ISBN-13 (GS1 mod-10). Available from the ISO catalogue.
• ISO/IEC 15417 (Code 128) — defines the modulo-103 checksum and the symbol's internal structure: iso.org/standard/43896.