SSCC-18 check digit calculator
The 17 data digits 00614141123456789 get check digit 0, so the full SSCC-18 is 006141411234567890. Compute the digit before a pallet label is printed, or validate an 18-digit code from a shipping notice so a typo never reaches the scanner. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Number
- 00614141123456789
- Calculation mode
- Compute
- Input
- 00614141123456789
- Check digit
- 0
- Sscc18
- 006141411234567890
Logistics labels, warehouse systems, and carrier integrations identify pallets and shipping units with an eighteen-digit Serial Shipping Container Code (SSCC-18). Seventeen of those digits carry the extension digit, the GS1 company prefix, and the serial reference; the eighteenth is a check digit derived from the GS1 mod-10 formula so that a single mistype or transposition is far more likely to fail than to look like a different valid container. This capability computes that check digit from a seventeen-digit data string, or validates a complete eighteen-digit SSCC and reports whether the stored trailing digit matches the recomputed value.
How the SSCC-18 check digit is calculated
The GS1 General Specifications define a single mod-10 check digit for the Serial Shipping Container Code and related AI (00) symbols. Take the seventeen data digits — extension digit, company prefix, and serial reference — and ignore any parentheses or application identifier you may see printed next to the bars. Number those data digits from the right: the rightmost data digit is multiplied by three, the next left by one, then three, then one, alternating until the leftmost digit is reached.
Sum every weighted product. The check digit is ten minus that sum modulo ten, taken modulo ten again so that a sum already divisible by ten yields check digit zero. Appending that single digit produces the full eighteen-digit SSCC encoded in the symbol and often printed in human-readable form beneath it.
Validation is the inverse: recompute the expected digit from the first seventeen characters and compare it to the eighteenth.
Where SSCC-18 check digits fit real logistics workflows
Shippers and 3PL operators receive a GS1 company prefix and assign serial references to pallets or outer cases; before a label printer burns the symbol they must append the correct check digit so warehouse scanners and carrier portals accept the unit on first scan. Warehouse management systems import supplier advanced shipping notices full of eighteen-digit SSCCs and should reject rows whose check digit no longer matches, which catches both human edits and off-by-one bugs in upstream generators.
Print shops that compose GS1-128 logistics labels from seventeen-digit serials call compute mode once per unit and place sscc18 under the bars. Do not treat a passing check digit as proof of GS1 allocation or ownership of the serial range — it only proves the eighteen-digit string is arithmetically well formed under the GS1 mod-10 rule, the same honesty bar you apply to any logistics checksum.
What you can do with it
Complete a seventeen-digit serial for pallet labels
Take the extension digit, GS1 company prefix, and serial reference (seventeen digits), call compute mode, and print sscc18 under the GS1-128 bars so the pallet label carries a scanner-valid SSCC-18.
Audit partner SSCC columns in EDI feeds
Batch-validate every SSCC-18 in a DESADV, CSV, or WMS export and quarantine rows whose check digit no longer matches the recomputed expected value.
FAQ
What is an SSCC-18 check digit?
It is the eighteenth digit of a Serial Shipping Container Code, computed from the first seventeen digits with GS1 alternating weights of 3 and 1 from the right so single-digit typos are far more likely to fail validation than to look like another container.
Is the SSCC-18 check digit tool free?
The browser tool is free and runs locally.
How is the SSCC check digit calculated?
Starting from the rightmost data digit, multiply the digits alternately by 3 and 1 and add the products. The check digit is what brings the sum up to a multiple of ten, or 0 if it already is one. For 00614141123456789 the digit is 0.
Should I type the (00) shown in front of the barcode?
No. The (00) printed beside the bars is the application identifier, not part of the code. Enter only the 17 data digits, or all 18 to validate; parentheses, spaces and hyphens are rejected instead of being silently removed.
Does a valid SSCC prove the serial belongs to my company?
No. A correct check digit only shows that the 18 digits add up. It does not prove that the GS1 company prefix was allocated to you or that the serial range is yours to use.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/enc/sscc \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"number":"00614141123456789"}'const res = await fetch("https://api.kit.forhosting.com/enc/sscc", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"number": "00614141123456789"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/sscc",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"number": "00614141123456789"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/sscc", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"number":"00614141123456789"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"number":"00614141123456789"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/sscc", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"number": "00614141123456789"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.sscc",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Non-numeric characters and wrong lengths are rejected with a clear invalid_input error instead of silently stripping garbage. Run it free in the browser or call the KIT API at the published price; both paths use the same pure arithmetic with no network round-trip and no stored SSCCs.
How the SSCC-18 check digit is calculated
The same weight schedule underpins other GS1 identifiers of different lengths, but this tool focuses strictly on the seventeen-plus-one SSCC-18 layout so search intent and API contracts stay clear. Because the algorithm is pure integer arithmetic with fixed weights, the same serial always produces the same check digit on every platform — browser, Worker, or offline test harness — which is why the capability ships as a tier-A parse engine rather than a model call.
How to compute a check digit or validate a full SSCC
Send a number field that contains only characters zero through nine. Mode validate expects exactly eighteen digits. Empty strings, missing number, invalid mode values, and wrong lengths (for example sixteen or nineteen digits) fail before any weighted sum runs and are not billed. Spaces, hyphens, letters, parentheses around application identifiers, and decimal points are rejected as non-numeric input with invalid_input so a form never accepts a silently cleaned value. Mode compute is the default: provide exactly seventeen data digits; the engine returns check_digit as a one-character string, sscc18 as the seventeen digits plus that check digit, and length eighteen. The response reports valid true when the trailing digit matches the recomputed expected_check_digit, and always includes payload (the first seventeen digits), check_digit as submitted, expected_check_digit, and the canonical sscc18 built from payload plus expected digit. That shape makes it easy to show “you typed X, expected Y” in a warehouse UI without a second request. Because the path is pure parse with no clock, random source, or network, the same input always yields the same JSON on the free browser tool and on the API. At $0.002 per successful request you can protect bulk ASN imports, label printers, and partner file audits without negotiating a custom tier. Prefer compute when you mint or complete a new container serial; prefer validate when you receive a full SSCC from a scanner, a WMS export, or a carrier feed and need a boolean gate before booking the shipment.
Where SSCC-18 check digits fit real logistics workflows
Carrier booking APIs that accept SSCC lists can validate on submit and block the tender until valid is true, reducing failed EDI or API rejections. Integration tests and data-quality jobs recompute expected_check_digit for every SSCC column in an export and quarantine mismatches before they reach the dock door.
Integration use cases
Validate scanned or typed SSCCs at receiving
When a handheld scanner or form submits eighteen digits, call validate mode and block ASN or put-away updates when valid is false, showing expected_check_digit to fix a mistype.
Technical questions
How do I compute an SSCC-18 check digit with this API?
POST with number set to exactly seventeen digits and mode compute (or omit mode). The response includes check_digit and sscc18 (the full eighteen-digit code).
How do I validate a full eighteen-digit SSCC?
POST with the eighteen-digit string and mode validate. The response includes valid, check_digit, expected_check_digit, payload, and the canonical sscc18.
What happens with letters, spaces, hyphens, or wrong lengths?
Non-numeric input and lengths other than seventeen (compute) or eighteen (validate) are rejected with invalid_input. Failed validation tasks are not billed.