Ethereum Address Checksums Explained: EIP-55 and Mixed Case

An Ethereum address checksum is a way of encoding an address's letters in a specific mix of uppercase and lowercase that lets wallets and applications detect typos before a transaction is sent, defined by EIP-55. A raw Ethereum address is just a 40-character hexadecimal string with no built-in error detection — EIP-55 adds that error detection back in, without changing the underlying address at all, purely by choosing which letters to capitalize.

The problem: hex addresses have no error checking

An Ethereum address is derived from a public key and represented as 40 hexadecimal characters (0-9 and a-f), typically shown with a 0x prefix. Hexadecimal digits, on their own, carry no redundancy — if someone mistypes, miscopies, or a single character gets corrupted when an address is transcribed, there's nothing in the format itself that flags the mistake. Since all lowercase hex characters are valid regardless of what the "correct" address actually was, a typo can easily produce another address that looks perfectly plausible, and funds sent to it are unrecoverable, the same way any misdirected transfer is — see our broader wallet security guide for why this class of mistake is unforgiving in crypto generally.

Bitcoin addresses solve a similar problem with Base58Check encoding, which includes an explicit checksum appended to the address. Ethereum addresses were designed without that redundancy built in from the start — but EIP-55 retrofitted a checksum using a clever trick that didn't require changing the address format itself.

How EIP-55's checksum works

EIP-55 doesn't add any new characters to the address. Instead, it defines a deterministic rule for which of the letters (a through f) in an address should be displayed as uppercase versus lowercase, based on a hash of the address itself:

1. Take the address (lowercase, without the 0x prefix) and compute its Keccak-256 hash.
2. For each letter character in the address (digits 0-9 are left alone, since case doesn't apply to them), look at the corresponding hex digit in the hash output.
3. If that hash digit is 8 or higher, capitalize the corresponding letter in the address; otherwise, keep it lowercase.

The result is an address like 0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAaD (note the specific mix of upper and lower case letters) rather than the flattened 0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaad. Because the capitalization pattern is a deterministic function of the address itself, any wallet or tool can recompute it and check whether the capitalization matches what it should be for that exact address.

If even a single character in the address was mistyped, the recomputed checksum capitalization almost certainly won't match what's actually displayed, and a checksum-aware wallet will flag it as invalid rather than silently accepting a possibly-wrong address.

What this means practically

Address form	Example pattern	Error detection
All lowercase	0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaad	None — any 40-hex-character string is technically "valid"
EIP-55 checksummed (mixed case)	0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAaD	Wallets can detect most single-character typos

Both forms refer to the exact same address — case doesn't change what account the address points to, since Ethereum addresses are case-insensitive at the protocol level. The checksum is purely a display and validation convention layered on top by wallets and tools, not a protocol-level requirement for transactions to be valid.

Where you'll encounter it

Most modern wallets and block explorers display addresses in checksummed form automatically and will warn you (or refuse to proceed) if you paste in an address whose capitalization doesn't match a valid checksum for that hex string — this is one of the few automated typo defenses you get when handling addresses. Developers building dapps are generally expected to validate address checksums client-side before submitting a transaction, and many libraries do this by default.

It's worth noting the checksum only catches accidental corruption of the address string — it does nothing to protect against sending to the correct address for the wrong purpose (like a scam contract, or an address you were tricked into trusting). For that class of risk, see our guide to common DeFi scams.

Why not just add extra characters, like Bitcoin does?

Bitcoin's Base58Check format appends explicit extra checksum characters to the address itself, which is a more conventional approach to error detection but comes with a real cost: it makes the address string itself longer, and it means the checksum scheme is baked permanently into the address format going forward. EIP-55's approach is notably more economical — it adds zero extra characters, reusing information that's already present (the letters' case, which carries no meaning in plain hexadecimal) to smuggle in a checksum for free. The tradeoff is that EIP-55's checksum is a display-layer convention rather than a protocol-level requirement: a transaction sent to an all-lowercase version of an address is just as valid at the protocol level as one sent to the properly-checksummed mixed-case version, since Ethereum's consensus rules don't care about letter casing at all. The checksum only helps to the extent that the software you're using — your wallet, an exchange's withdrawal form, a contract's frontend — actually checks it before letting you proceed.

What to do if you're not sure an address is checksummed correctly

If you're ever manually transcribing an address (which is generally worth avoiding altogether in favor of copy-paste or scanning a QR code), most wallets and several dedicated online tools can validate whether a given address string matches its expected EIP-55 checksum. If a tool reports a mismatch, treat that as a strong signal something in the address was altered or mistyped, and re-verify the original source rather than assuming the checksum tool is simply being overly strict.

Bottom line

EIP-55 turns Ethereum's plain hex addresses into a lightweight, self-checking format by encoding a checksum purely through letter capitalization, derived from a hash of the address itself. It doesn't change what the address is or how transactions work at the protocol level — it just gives wallets a reliable way to catch the specific, common failure mode of a mistyped or corrupted address before you send funds somewhere you didn't intend. Always let your wallet validate the checksum rather than manually retyping an address, and treat a checksum warning as a hard stop, not a suggestion.