ISO 7064 mod 97-10 check digits
For 123456 the ISO 7064 MOD 97-10 check digits are 76, giving 12345676: the same two-digit rule that protects IBAN check digits, applied to any code of letters and digits. Validate mode checks a code that already carries them. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- 123456
- Calculation mode
- Compute
- Input
- 123456
- Check digits
- 76
- With check
- 12345676
Long account references, payment identifiers, and warehouse codes are easy to mistype, and a single wrong character can send money or goods to the wrong place. The ISO 7064 MOD 97-10 check digit system appends two decimal digits so that almost every single-character error and many transposition errors break the checksum. Letters are mapped A equals ten through Z equals thirty-five before the modular arithmetic, matching the hybrid character set used by IBAN-style schemes and other MOD 97-10 codes.
What ISO 7064 MOD 97-10 is and why two digits matter
Check digits exist because humans, keyboards, OCR, and hand-copying introduce predictable damage: one wrong character, two neighboring symbols swapped, or a digit dropped or inserted. ISO 7064 defines several modular check systems; MOD 97-10 is the pure (and hybrid-alphanumeric) system that produces two check characters from the digit alphabet zero through nine.
In practice you map letters A through Z to the two-digit values ten through thirty-five, treat the whole string as a large integer in base ten after that expansion, and require that integer to be congruent to one modulo ninety-seven when the two check digits are included. To mint check digits you temporarily append two zeros, take the remainder modulo ninety-seven, and set the check value to ninety-eight minus that remainder, always written as two digits from zero-one through ninety-eight.
That construction is exactly what international bank account numbers use under the hood for their two check digits after the country code, and the same math protects SEPA-related references, some national creditor identifiers, and internal codes that chose MOD 97-10 for its strong residual distribution. Two check digits give a modulus of ninety-seven, a prime, which yields far better residual coverage than a single mod-ten digit for the typo patterns people actually make.
Compared with single-digit schemes such as Damm or Luhn, MOD 97-10 is the right choice when your domain already documents ISO 7064 or IBAN-family rules and you need two decimal check digits rather than one.
Where MOD 97-10 check digits fit real systems
Treasury and payments teams that build internal payment references alongside IBAN fields need the same two-digit check rule without pulling a full banking library. Membership and loyalty programs mint alphanumeric IDs and want a trailing pair that call-center agents and mobile keyboards will not silently corrupt. Warehouse and logistics teams print carton or asset codes; a transposition of two digits on a handheld path is common, and a ninety-seven modulus catches far more of those errors than a single mod-ten digit.
Healthcare and education offices that still move paper forms with multi-character reference numbers can validate on entry and show an immediate correction instead of creating a duplicate chart or enrollment. Integration tests and data-quality jobs recompute the expected check digits for every row in a CSV export and flag rows where the stored full code no longer matches, which catches both human edits and off-by-one bugs in generators.
Product teams that already use Luhn for card-like fields can still adopt MOD 97-10 for internal identifiers where the domain standard or partner contract already specifies ISO 7064. Do not treat a passing MOD 97-10 check as proof of authorization, ownership, or that a string is a real bank account in a given country — it only proves the character string is well formed under this algorithm, the same honesty bar you apply to any checksum.
What you can do with it
Audit exported code columns
Batch-validate every alphanumeric reference in a partner CSV or warehouse export and quarantine rows whose check digits no longer match the recomputed expected value.
FAQ
What is the ISO 7064 mod 97-10 check digit?
It is a two-digit decimal check computed with modulus 97 so that almost any single-character error in an alphanumeric code makes the full string fail validation.
What happens with spaces, hyphens, or other symbols?
Provide A-Z and 0-9 only; failed validation tasks are not billed.
Is the mod 97-10 check digit tool free?
The browser tool is free and runs locally.
How are the two check digits calculated?
Two zeros are added to the end of the code, the remainder after dividing by ninety-seven is taken, and the check is ninety-eight minus that remainder, always written with two digits. For 123456 that gives 76.
Can I use this to validate a whole IBAN?
Only its arithmetic core. A full IBAN check also moves the country code and check digits to the end and verifies the length for each country, which this tool does not do. It gives you the shared MOD 97-10 step.
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/mod97 \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"123456"}'const res = await fetch("https://api.kit.forhosting.com/enc/mod97", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "123456"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/mod97",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "123456"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/mod97", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"123456"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"123456"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/mod97", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "123456"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.mod97",
"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
This capability computes those two digits for an alphanumeric payload you already have, or validates a complete string that already includes them, and it rejects non-alphanumeric input with a clear 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 and no stored secrets.
What ISO 7064 MOD 97-10 is and why two digits matter
This tool implements that standard walk with iterative remainder reduction so long codes never overflow JavaScript numbers, and it always labels the algorithm as iso7064_mod97_10 so downstream systems can record which scheme protected the value.
How to compute check digits or validate a full code
Send a text field that contains only characters A through Z and digits zero through nine. Letter case is ignored; the engine uppercases before mapping. Empty strings, missing text, and invalid mode values fail before any arithmetic runs and are not billed. Note that full IBAN validation also rearranges country and check positions and applies country-length tables; this capability is the shared MOD 97-10 core, not a full IBAN country-format checker. Spaces, hyphens, punctuation, and other symbols are rejected as non-alphanumeric input with invalid_input so you never accept a silently stripped value. Mode compute is the default: the engine maps the payload, appends two zeros, reduces modulo ninety-seven, returns check_digits as a two-character string, and returns with_check as the payload plus those digits so you can store or print a single string. Mode validate expects a full string of at least three characters (one or more payload characters plus the two trailing check digits). The trailing pair must be decimal digits; if they are letters the request fails before any modular walk. The response reports valid true when the full mapped integer is congruent to one modulo ninety-seven, and always includes the trailing check_digits, the expected_check_digits recomputed from the payload alone, and the payload substring without the last two characters. That shape makes it easy to show “you typed X, expected Y” in a form without a second call. 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 imports, onboarding forms, and batch label printers without negotiating a custom tier. Prefer compute when you mint new codes; prefer validate when you receive a code from a user, a partner file, or a scanned label and need a boolean gate before looking up the record.
Integration use cases
Mint protected account or reference codes
Generate an alphanumeric payload, call compute mode, and store with_check so every new code carries ISO 7064 mod 97-10 trailing digits before it is printed or emailed.
Validate typed or scanned codes at entry
When a user or scanner submits a full code, call validate mode and block lookup when valid is false, showing expected_check_digits to help correct a mistype.
Technical questions
How do I compute mod 97-10 check digits with this API?
POST with text set to the payload (A-Z, 0-9) and mode compute (or omit mode). The response includes check_digits and with_check (payload plus the two digits).
How do I validate a code that already has check digits?
POST with the full alphanumeric string and mode validate. The response includes valid, check_digits, expected_check_digits, and payload without the last two characters.