IMEI Validation in Python — Luhn Algorithm for Device IDs

1. What is an IMEI?

An IMEI (International Mobile Equipment Identity) is a 15-digit number that uniquely identifies a mobile device on a cellular network. Defined by GSMA and standardised in 3GPP TS 23.003, IMEIs are assigned at the factory and stored in a phone's firmware.

Carriers use IMEIs to block stolen devices from accessing networks. Device management platforms (MDM) use them to inventory assets. E-commerce and insurance platforms use them to verify device identity before processing trade-ins or claims.

You can find an IMEI by dialling *#06# on any mobile device, in Settings, or on the original packaging.

2. IMEI anatomy — TAC, SNR, and check digit

Every IMEI has exactly 15 digits, structured as three components:

3. Luhn mod-10 applied to IMEI

The Luhn algorithm (mod-10) is identical for IMEIs and credit cards. Starting from the second-to-last digit and moving left, double every second digit. Subtract 9 from any result greater than 9. Sum all digits. If the total is divisible by 10, the number is valid.

Let's walk through a known-valid IMEI: 356741080123456

# luhn_imei.py — validate an IMEI using the Luhn algorithm
import re


def validate_imei(raw: str) -> bool:
    """Validate an IMEI using the Luhn mod-10 algorithm.

    Strips spaces, hyphens, and dots (common separators in printed IMEIs).
    Returns True if the IMEI has exactly 15 digits and passes Luhn.
    """
    # Strip common separators
    digits = re.sub(r"[\s\-.]+", "", raw)

    if not re.fullmatch(r"\d{15}", digits):
        return False  # must be exactly 15 digits

    total = 0
    for i, ch in enumerate(reversed(digits)):
        d = int(ch)
        if i % 2 == 1:  # double every second digit from the right
            d *= 2
            if d > 9:
                d -= 9
        total += d

    return total % 10 == 0


print(validate_imei("356741080123456"))  # True  ✓
print(validate_imei("356741080123457"))  # False ✗ — one digit off
print(validate_imei("12345678901234"))   # False ✗ — 14 digits

4. Why a regex is not enough

# 15-digit IMEI — Luhn check applies
"356741080123456"

# 16-digit IMEI/SV — Luhn check does NOT apply to the full string
"3567410801234560"  # last 2 digits = software version, not check digit

5. The production-ready solution

The IsValid IMEI API handles input normalisation, exact-length validation, and the Luhn checksum in a single GET request. The response includes the parsed TAC, SNR, and check digit — useful for logging and device classification.

Get your free API key at isvalid.dev. The free tier includes 100 calls per day — enough for most development and low-volume production use.

Full parameter reference and response schema: IMEI Validation API docs →

6. Python code example

Using the isvalid-sdk Python SDK or the popular requests library. Install either with pip install isvalid-sdk or pip install requests.

# imei_validator.py
import os
from isvalid_sdk import IsValidConfig, create_client

iv = create_client(IsValidConfig(api_key=os.environ["ISVALID_API_KEY"]))

result = iv.imei("35-674108-012345-6")

if not result["valid"]:
    print("Invalid IMEI")
else:
    print("Valid IMEI")
    print(f"TAC (device model): {result['tac']}")      # → "35674108"
    print(f"SNR (serial): {result['snr']}")              # → "012345"
    print(f"Check digit: {result['checkDigit']}")        # → "6"

# app.py (Flask)
import re
from flask import Flask, request, jsonify

app = Flask(__name__)


@app.post("/devices/register")
def register_device():
    data = request.get_json()
    imei = data.get("imei", "")

    try:
        imei_check = validate_imei(imei)
    except requests.RequestException:
        return jsonify(error="IMEI validation service unavailable"), 502

    if not imei_check["valid"]:
        return jsonify(error="Invalid IMEI number"), 400

    # Store normalised — TAC identifies the device model family
    device = db.devices.create(
        imei=re.sub(r"[\s\-.]+", "", imei),  # store without separators
        tac=imei_check["tac"],
        snr=imei_check["snr"],
        **{k: v for k, v in data.items() if k != "imei"},
    )

    return jsonify(success=True, device_id=device.id)

7. cURL example

Validate a raw 15-digit IMEI:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/imei?value=356741080123456"

GSMA display format with hyphens:

curl -G -H "Authorization: Bearer YOUR_API_KEY" \
  --data-urlencode "value=35-674108-012345-6" \
  "https://api.isvalid.dev/v0/imei"

Invalid IMEI (bad check digit):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/imei?value=356741080123457"

8. Understanding the response

Valid IMEI:

{
  "valid": true,
  "tac": "35674108",
  "snr": "012345",
  "checkDigit": "6"
}

Invalid IMEI (bad checksum or wrong length):

{
  "valid": false
}

Fields tac, snr, and checkDigit are only present when valid is true.

9. Use cases and edge cases

# Bulk validation with error collection
import csv


def register_devices(csv_path: str) -> dict:
    valid_devices = []
    invalid_imeis = []

    with open(csv_path) as f:
        for row in csv.DictReader(f):
            try:
                check = validate_imei(row["imei"])
            except Exception:
                invalid_imeis.append(row["imei"])
                continue

            if not check["valid"]:
                invalid_imeis.append(row["imei"])
            else:
                valid_devices.append({
                    **row,
                    "tac": check["tac"],
                    "snr": check["snr"],
                })

    return {"valid": valid_devices, "invalid": invalid_imeis}

Python integration notes

Pydantic V2's Annotatedtype with AfterValidatorintegrates IMEI validation directly into your data models. Define the annotated type once and use it in FastAPI request bodies, SQLModel ORM models, and Pydantic dataclasses. The validator raises aValueError with the API's error message, which Pydantic automatically surfaces in validation error details — no extra error-mapping code needed.

Bulk validation of IMEI values — during an import, a migration, or a compliance scan — is most efficient withasyncio.gather()bounded by an asyncio.Semaphore. Process in chunks of 50–100 items, writing each chunk's results to the database before moving on to keep memory usage bounded and the job resumable.

Pre-process IMEI values before calling the API:.strip() trims whitespace, re.sub(r'\s+', '', value)removes internal spaces, andunicodedata.normalize('NFC', value)resolves Unicode normalisation issues from multiple source systems.

• Use python-dotenv to load ISVALID_API_KEY and assert it at startup
• Test async validation functions with pytest-asyncio and mock HTTP calls with respx
• Annotate validated fields as NewType('Imei', str) for self-documenting function signatures
• Use functools.lru_cache on the synchronous validation wrapper for scripts that check the same values repeatedly