MEID check digit calculator
For the MEID body 6C4BFFC0000004 the check digit is 4, giving the fifteen-character 6C4BFFC00000044: the standard Luhn rule worked in base 16 over the hex digits 0 to 9 and A to F. You can also validate a full MEID. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Meid
- 6C4BFFC0000004
- Calculation mode
- Compute
- Input
- 6C4BFFC0000004
- Check digit
- 4
- Meid
- 6C4BFFC00000044
CDMA and multi-mode handsets identify the radio with a Mobile Equipment Identifier (MEID): fourteen hexadecimal digits that encode manufacturer and serial fields, plus an optional fifteenth check character computed so that a single mistype or transposition is far more likely to fail than to look like another device. This capability computes that check digit with the standard Luhn mod-16 formula over hex alphabet 0-9A-F, or validates a complete fifteen-hex-digit MEID and reports whether the stored trailing character matches the recomputed value.
How the MEID check digit is calculated
A MEID body is always fourteen hexadecimal digits. The optional check character is one more symbol from the same alphabet 0-9A-F, produced by the Luhn mod-N algorithm with N equal to sixteen. Each product is reduced with the base-sixteen digit sum floor(product/16) plus product modulo sixteen, then all reduced values are summed.
The check code point is sixteen minus that sum modulo sixteen, taken modulo sixteen again so a sum already divisible by sixteen yields check character zero. Appending that single hex character produces the fifteen-symbol string used in inventory labels, provisioning feeds, and audit CSVs. Validation is the inverse: recompute the expected character from the first fourteen symbols and compare it to the fifteenth.
Note that a passing check digit proves only arithmetic well-formedness; it does not prove GSMA allocation, carrier whitelist status, or that the device is not reported lost.
Where MEID check digits fit real device workflows
Device manufacturers and ODMs assign serial fields under a manufacturer code and must append the correct check character before laser etching or packaging labels so carrier and enterprise intake systems accept the identifier on first scan. Carriers and MVNOs import partner CSVs of fifteen-hex-digit MEIDs and should reject rows whose check digit no longer matches, which catches both human edits and off-by-one bugs in upstream generators.
Enterprise mobile-device-management and RMA desks let technicians type or scan an MEID and can validate on blur, blocking warranty enrollment until valid is true and reducing failed ticket opens. Print shops that compose asset tags from fourteen-digit MEID bodies call compute mode once per unit and place the fifteen-character string under the barcode graphic.
Do not treat a passing check digit as proof of ownership, network authorization, or uniqueness in the wild — it only proves the fifteen-symbol string is arithmetically well formed under Luhn mod 16, the same honesty bar you apply to any equipment checksum.
What you can do with it
Complete a fourteen-digit MEID for print or etch
Take the manufacturer and serial fields (fourteen hex digits), call compute mode, and print or laser meid under the asset barcode so the label carries a Luhn-valid fifteen-character identifier.
Audit partner device identifier columns
Batch-validate every MEID in a carrier or ODM CSV export and quarantine rows whose check digit no longer matches the recomputed expected value.
FAQ
What is a MEID check digit?
It is the optional fifteenth hexadecimal character of a Mobile Equipment Identifier, computed from the first fourteen hex digits with Luhn mod 16 so single-character typos are far more likely to fail validation than to look like another device.
What happens with non-hex characters, spaces, or wrong lengths?
Spaces, hyphens, colons, and dots are stripped for paste convenience. Failed validation tasks are not billed.
Is the MEID check digit tool free?
The browser tool is free and runs locally.
How is the MEID check digit calculated?
With Luhn in base 16. Working from the right of the fourteen-digit body, the hex values (A is 10, F is 15) are multiplied by 2 and 1 in turn, each product is reduced to its base-16 digit sum, and the check makes the total divisible by 16.
Does a valid MEID check digit prove the phone is legitimate?
No. It only proves that the fifteen characters are arithmetically well formed. It says nothing about manufacturer allocation, carrier approval, ownership or whether the device has been reported lost, so other checks are still needed.
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/meid \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"meid":"6C4BFFC0000004"}'const res = await fetch("https://api.kit.forhosting.com/enc/meid", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"meid": "6C4BFFC0000004"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/meid",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"meid": "6C4BFFC0000004"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/meid", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"meid":"6C4BFFC0000004"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"meid":"6C4BFFC0000004"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/meid", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"meid": "6C4BFFC0000004"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.meid",
"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
Spaces, hyphens, and colons are stripped for paste convenience; any other non-hex character and wrong lengths are rejected with a clear invalid_input error instead of silently rewriting 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 identifiers.
How the MEID check digit is calculated
Working from the right of the fourteen-digit payload, alternate factors two and one are applied to each nibble code point (A maps to ten, B to eleven, through F as fifteen). Because the algorithm is pure integer arithmetic with a fixed alphabet, the same MEID 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 MEID
Send a meid field that contains hexadecimal characters only after optional separators are removed. Mode validate expects exactly fifteen hex digits. Empty strings, missing meid, invalid mode values, and wrong lengths (for example thirteen or sixteen digits) fail before any Luhn pass runs and are not billed. Spaces, hyphens, colons, and dots are stripped so that strings like 6C4B-FFC0-0000-04 paste cleanly; any remaining letter outside A-F or any other symbol is rejected as malformed hexadecimal input with invalid_input so a form never accepts a silently cleaned value. Mode compute is the default: provide exactly fourteen hex digits; the engine returns check_digit as a one-character uppercase hex string, meid as the fourteen digits plus that check character, and length fifteen. The response reports valid true when the trailing character matches the recomputed expected_check_digit, and always includes payload (the first fourteen digits), check_digit as submitted, expected_check_digit, and the canonical meid built from payload plus expected character. That shape makes it easy to show “you typed X, expected Y” in a warehouse or RMA 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 device imports, label printers, and partner file audits without negotiating a custom tier. Prefer compute when you mint or complete a new MEID for print or provisioning; prefer validate when you receive a full identifier from a scanner, a CSV, or a supplier feed and need a boolean gate before storing the asset record.
Where MEID check digits fit real device workflows
Integration tests and data-quality jobs recompute expected_check_digit for every MEID column in an export and quarantine mismatches before they reach the provisioning HLR or device blacklist.
Integration use cases
Validate scanned or typed MEIDs at intake
When a handheld scanner or form submits fifteen hex digits, call validate mode and block inventory or warranty updates when valid is false, showing expected_check_digit to fix a mistype.
Technical questions
How do I compute a MEID check digit with this API?
POST with meid set to exactly fourteen hex digits and mode compute (or omit mode). The response includes check_digit and meid (the full fifteen-hex-digit string).
How do I validate a full fifteen-hex-digit MEID?
POST with the fifteen-character hex string and mode validate. The response includes valid, check_digit, expected_check_digit, payload, and the canonical meid.