For UICC, SIM, eSIM, and modem developers

ICCID Decoder & EF_ICCID Converter

Inspect a printed ICCID or convert the 10-byte EF_ICCID hexadecimal value in either direction. See the industry identifier, country-code hint, Luhn result, swapped-nibble BCD, and machine-readable JSON.

Decoder / 01

Decode or convert an ICCID

Use either form. The decoder module performs the conversion on this device without sending the identifier to this site's processing server.

Enter 18–20 digits for compatibility analysis. Current E.118 conformance requires 19 digits; spaces and hyphens are accepted.

or decode raw file bytes

Exactly 10 bytes. Spaces, colons, and hyphens are accepted.

Structural decoding only. This tool does not query carrier systems or activation records.

Ready to decode

Enter printed digits or the 10 bytes read from EF_ICCID. The result will show both representations and explain the format checks.

Device workflow / 02

Choose the ICCID representation your device returned.

Printed decimal digits and raw EF_ICCID bytes represent the same identifier differently. Preserve the source value for audit, then paste only the payload expected by the matching form.

Card, packaging, or profile export

Use the printed-digits form for the decimal characters shown on a SIM label, carrier inventory file, or eSIM profile record. The converter accepts 18–20 digits for compatibility investigation, but only the 19-digit mode represents current E.118 length conformance.

Modem AT+CCID response

AT command names and response wrappers vary by modem. Copy the decimal ICCID payload, but remove labels such as +CCID:, quotes, and unrelated response lines before using the printed-digits form.

READ BINARY from file 2FE2

Use the hexadecimal form for exactly the 10 EF_ICCID data bytes. Do not append APDU status words such as 9000; status bytes describe the command result and are not part of EF_ICCID.

Keep both layers: save the original modem or APDU response separately from the normalized ICCID. That makes nibble-order, padding, and parser problems reproducible without treating command wrappers as identifier digits.

How EF_ICCID stores printed digits.

ETSI TS 102 221 defines EF_ICCID as file identifier 2FE2, a transparent 10-byte field. Its BCD digits are left aligned, padded with F, and stored with the first printed digit in the low nibble of each byte.

Printed ICCID: 8910112345678901238. The decimal value contains 19 digits and no F; F is added only as the twentieth storage nibble.

19 digits + EF filler 89 10 11 23 45 67 89 01 23 8F
EF_ICCID bytes 98 01 11 32 54 76 98 10 32 F8

Fixed 10-byte field

EF_ICCID contains 20 nibbles. A 19-digit value receives one trailing F filler nibble before each digit pair is encoded.

Low nibble first

Printed digits 89 become byte 98. The display looks reversed because digit 1 occupies the byte's low nibble.

Padding is not a digit

Trailing F fills unused BCD positions. The decoder removes only valid trailing filler and rejects malformed padding.

Primary references

ETSI file coding and ITU numbering.

The byte conversion follows ETSI TS 102 221 V18.1.0, clause 13.2. Current ITU-T E.118 specifies a 19-digit PAN for ICCID numbering. Country, area, and service hints use a pinned open E.164 metadata snapshot with shared codes left unresolved; see the source and license boundary.

Conformance kit / 04

Reproducible EF_ICCID test vectors for encoders and parsers.

Run the same deterministic fixtures in unit tests, modem import jobs, APDU parsers, and CI. The suite keeps byte conversion, Luhn mathematics, the 89 MII, and current E.118 conformance as separate expected results.

Case Input Direction Expected Printed ICCID EF_ICCID Luhn Current E.118
Current 19-digit ICCID8910112345678901238printed-to-efAccepted891011234567890123898 01 11 32 54 76 98 10 32 F8PassYes
Printed separators8910 1123-4567 8901 238printed-to-efAccepted891011234567890123898 01 11 32 54 76 98 10 32 F8PassYes
18-digit compatibility input891011234567890123printed-to-efAccepted89101123456789012398 01 11 32 54 76 98 10 32 FFNot evaluatedNo
20-digit compatibility input89101123456789012389printed-to-efAccepted8910112345678901238998 01 11 32 54 76 98 10 32 98Not evaluatedNo
Wrong Luhn digit8910112345678901234printed-to-efAccepted891011234567890123498 01 11 32 54 76 98 10 32 F4FailNo
Wrong MII, Luhn pass9910112345678901237printed-to-efAccepted991011234567890123799 01 11 32 54 76 98 10 32 F7PassNo
Formatted EF_ICCID0x98 01:11-32 54 76 98 10 32 f8ef-to-printedAccepted891011234567890123898 01 11 32 54 76 98 10 32 F8PassYes
Two F filler nibbles98 01 11 32 54 76 98 10 32 FFef-to-printedAccepted89101123456789012398 01 11 32 54 76 98 10 32 FFNot evaluatedNo
No filler nibble98 01 11 32 54 76 98 10 32 98ef-to-printedAccepted8910112345678901238998 01 11 32 54 76 98 10 32 98Not evaluatedNo
Wrong byte length98 01 11 32 54 76 98 10 32ef-to-printedRangeError——Not evaluatedNo
APDU status appended98 01 11 32 54 76 98 10 32 F8 90 00ef-to-printedRangeError——Not evaluatedNo
Non-hex character98 01 11 32 54 76 98 10 32 G8ef-to-printedTypeError——Not evaluatedNo
Invalid BCD nibble98 01 11 32 54 76 98 10 32 A8ef-to-printedTypeError——Not evaluatedNo
Internal F filler98 01 11 F2 54 76 98 10 32 F8ef-to-printedTypeError——Not evaluatedNo

Fixture boundary: acceptance means the converter can represent the input in the 10-byte field. Only a 19-digit value beginning with 89 and passing Luhn is marked current E.118 conformant. These values are structural fixtures, are not claimed to be unassigned, and do not prove issuance, carrier ownership, activation, or network access.

Reference code / 05

Minimal JavaScript and Python EF_ICCID codecs.

Both examples enforce a 10-byte hexadecimal payload, reverse the two nibbles in each byte, and permit F only as trailing storage filler. Apply E.118 structure and Luhn checks after conversion.

JavaScriptencode + decode
function encodeEfIccid(value) {
  const digits = value.replace(/[\s-]/g, "");
  if (!/^[0-9]{18,20}$/.test(digits)) throw new TypeError("18-20 digits required");
  return digits.padEnd(20, "F").match(/../g)
    .map(([a, b]) => b + a).join("");
}

function decodeEfIccid(value) {
  const hex = value.trim().replace(/^0x/i, "")
    .replace(/[\s:-]/g, "").toUpperCase();
  if (!/^[0-9A-F]{20}$/.test(hex)) throw new TypeError("10 hex bytes required");
  const swapped = hex.match(/../g)
    .map(([a, b]) => b + a).join("");
  if (!/^[0-9]{18,20}F{0,2}$/.test(swapped)) throw new TypeError("Invalid BCD or filler");
  return swapped.replace(/F+$/, "");
}
Pythonencode + decode
import re

def encode_ef_iccid(value: str) -> str:
    digits = re.sub(r"[\s-]", "", value)
    if not re.fullmatch(r"[0-9]{18,20}", digits):
        raise ValueError("18-20 digits required")
    padded = digits.ljust(20, "F")
    return "".join(b + a for a, b in zip(padded[::2], padded[1::2]))

def decode_ef_iccid(value: str) -> str:
    cleaned = re.sub(r"^0x", "", value.strip(), flags=re.IGNORECASE)
    encoded = re.sub(r"[\s:-]", "", cleaned).upper()
    if not re.fullmatch(r"[0-9A-F]{20}", encoded):
        raise ValueError("10 hex bytes required")
    swapped = "".join(b + a for a, b in zip(encoded[::2], encoded[1::2]))
    if not re.fullmatch(r"[0-9]{18,20}F{0,2}", swapped):
        raise ValueError("Invalid BCD or filler")
    return swapped.rstrip("F")
Use the fixture fields as distinct assertions

conversionSupported describes this codec's compatibility range. luhnValid is checksum mathematics. currentE118Conformant additionally requires the current 19-digit length and 89 telecommunications MII. None of them is an activation lookup.

FAQ / 06

ICCID decoding questions

Practical answers about EF_ICCID bytes, swapped nibbles, number length, carrier identification, and privacy.

What is EF_ICCID?

EF_ICCID is the UICC elementary file with identifier 2FE2 that stores the card identification number. ETSI TS 102 221 defines it as a transparent 10-byte file using BCD, left alignment, and F padding.

Why do EF_ICCID hexadecimal digits look swapped?

The first printed digit is stored in the low nibble and the second digit in the high nibble of each byte. Therefore printed digits 89 are represented by hexadecimal byte 98.

Can this decoder identify the SIM carrier?

It reports a country, area, or global-service hint from a pinned E.164 metadata snapshot but does not claim carrier ownership, location, or activation. Shared codes remain shared. Accurate issuer matching requires maintained official IIN information from ITU or the relevant national administration.

Does the converter accept 18, 19, and 20 digits?

For compatibility analysis, yes. Current ITU-T E.118 defines a 19-digit PAN. An 18-digit value may be a body without its parity digit or truncated input, while a 20-digit decimal value may be interface-specific. Conversion does not mean either length conforms to current E.118.

Is the ICCID sent to a server?

The ICCID decoder module performs BCD conversion, checksum calculation, copying, and JSON creation in the browser without sending the identifier to this site's processing server. The page still loads site files and Google advertising and consent services; see the methodology page for the exact boundary.