You copy an Ethereum address from an exchange, paste it into a wallet, and notice a mix of capital and small letters: 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359. Does the case matter? Would the same address in all lowercase send money somewhere else?
No. Ethereum addresses are not case sensitive. The network reads an address as 20 bytes, and 0xFB69... and 0xfb69... are the same bytes, so they point to the same account. The capitals are a checksum layered on top by ERC-55, and they matter only to the software that checks them: a wallet that sees a mixed-case address with the wrong pattern of capitals will refuse it, because that pattern is how a typo gets caught.
Why the network ignores case
An Ethereum account address is “the last 20 bytes of the Keccak-256 hash of the public key” with 0x in front, according to ethereum.org’s account documentation. Twenty bytes written in hexadecimal are 40 characters, each one 0 to 9 or a to f. Hexadecimal does not distinguish A from a: both mean the value ten. A transaction carries the raw bytes, not the text you pasted, so the letters’ case never reaches the chain.
That left early Ethereum with a gap. A 40-character hex string has no built-in way to tell a correct address from one with a mistyped character, and a mistyped address is still a valid destination. Funds sent there are gone.
How the capitals become a checksum
ERC-55, written by Vitalik Buterin and Alex Van de Sande and created on January 14, 2016 (status Final), fills that gap without changing the address length. The rule from the specification:
- Write the address in lowercase hex, without
0x. - Hash that 40-character text with Keccak-256.
- For each position that holds a letter (
atof), look at the hash’s hex digit in the same position. If it is 8 or higher, write the letter in uppercase. Otherwise leave it lowercase. Digits stay as they are.
Here is the first stretch of one of the specification’s own test addresses, worked through. We computed the Keccak-256 hash ourselves and checked that our code reproduces all four of the specification’s mixed-case test vectors.
| Position | Address character | Hash digit | Rule | Result |
|---|---|---|---|---|
| 0 | f | 5 | letter, 5 is below 8 | f |
| 1 | b | c | letter, c (12) is 8 or more | B |
| 2 | 6 | f | digit, no case | 6 |
| 3 | 9 | a | digit, no case | 9 |
| 9 | c | 4 | letter, 4 is below 8 | c |
| 10 | a | 5 | letter, 5 is below 8 | a |
The hash of fb6916095ca1df60bb79ce92ce3ea74c37c5d359 begins 5cfac663f45837b409c4..., and running the rule across all 40 positions gives 0xfB6916095ca1df60bB79Ce92cE3Ea74c37c5d359, exactly as in the specification.
Now change only the last character, 9 to 8, as a tired hand might. The hash of the new address is entirely different, so its correct checksum is 0xfB6916095Ca1df60bb79cE92Ce3ea74C37c5d358. The string you would have typed, with the old capitals and the new last digit, matches it in neither the C at position 9 nor several later letters, so a checking wallet rejects it.
How well it catches mistakes: our numbers
The specification says that “on average there will be 15 check bits per address” and that a mistyped address has a 0.0247% chance of passing. Both figures follow from simple arithmetic, and we checked them two ways.
The calculation. Each of the 40 positions is a letter with probability 6/16. A letter carries one check bit: a wrong address guesses its case right half the time. So the expected number of letters is 40 × 6/16 = 15, and the chance that a random wrong address matches every capital is (10/16 + 6/16 × 1/2)^40 = (13/16)^40 = 0.000247, which is 0.0247%, about 1 in 4,050.
The simulation. On November 15, 2026 we generated 20,000 random addresses and then made 200,000 single-character typos in correctly checksummed addresses, replacing one character at random with a different hex character in random case.
| Measure | Result |
|---|---|
| Average letters per address (20,000 addresses) | 15.0 |
| Fewest and most letters seen | 4 and 29 |
| Addresses with 8 letters or fewer | 1.38% |
| Single-character typos rejected by the checksum | 199,893 of 200,000 (99.95%) |
| Typos that still passed the checksum | 38 (0.019%) |
| Typos that turned the address all lowercase or all uppercase | 69 (0.035%) |
The last row is the part most explanations skip. ERC-55’s own test cases list all-caps and all-lowercase addresses as acceptable, because the scheme had to stay compatible with addresses written before it existed. Software that follows that rule treats such a string as “no checksum supplied” and accepts it. When a checksummed address happens to have only a few letters, all of them lowercase, a typo that lands on a digit or a small letter produces an all-lowercase string, and the check simply switches off. In our run that path let through more typos than the checksum itself.
The protection is also uneven between addresses. A string with L letters carries L check bits, so a wrong one passes with probability 1 in 2^L: about 1 in 32,800 at 15 letters, 1 in 256 at 8 letters, and 1 in 16 at 4.
What wallets and tools do with it
The checksum is enforced by software, not by the protocol, so behavior depends on the tool:
- ethers.js v6.
getAddressturns an all-lowercase address into its checksummed form and throwsbad address checksumwhen it is given mixed case with the wrong capitals. - Solidity. The Address Literals section of the Solidity documentation says hex literals of address length that fail the checksum test “produce an error” at compile time.
- Other EVM networks. ERC-1191, still in Last Call, adds the chain ID to the hash so that an address copied from one network fails the check on another. Its implementation lists only chain IDs 30 and 31 (RSK mainnet and testnet) as adopters, and its test vectors show the same account with different capitals on RSK than on Ethereum. A capital pattern that a strict Ethereum tool rejects can therefore be correct on RSK.
What the checksum cannot do is tell you an address is the one you meant. Address-poisoning scams send you a tiny transfer from a lookalike address that shares the first and last few characters with one you use. That lookalike is a real address with its own perfectly valid checksum, so every check passes. Compare more than the ends of the string, or use your wallet’s address book.
Bitcoin is different
People asking this question often hold Bitcoin too, and the answer there depends on the address format.
| Format | Example prefix | Case sensitive? | Error check |
|---|---|---|---|
| Ethereum hex | 0x | No; case is optional ERC-55 checksum | About 15 check bits on average, 0.0247% miss rate per ERC-55 |
| Bitcoin legacy (Base58Check) | 1, 3 | Yes: changing case changes the value | 4-byte double-SHA256 checksum, verified in Bitcoin Core’s base58.cpp |
| Bitcoin SegWit v0 (Bech32) | bc1q | No, but mixed case is invalid | Detects any error in up to 4 characters, under 1 in 10^9 misses beyond that, per BIP-173 |
| Bitcoin Taproot and later (Bech32m) | bc1p | No, but mixed case is invalid | Bech32 with a changed constant that fixes an insertion weakness, per BIP-350 |
BIP-173 is explicit on case: encoders “MUST always output an all lowercase” string, uppercase is allowed for QR codes, and decoders “MUST NOT accept” mixed case. So with Bitcoin, a legacy address retyped in the wrong case is a different string that will usually fail its checksum, while a bc1 address can be all lowercase or all uppercase but never both.
What to do with an address in practice
- Copy and paste instead of retyping, and keep the capitals exactly as they came. They are your typo detector.
- If a wallet shows a checksum error, do not “fix” it by lowercasing the address. Lowercasing removes the check; it does not repair the mistake. Get the address again from its source.
- Lowercasing a correct address is harmless. It still reaches the same account, but you lose the protection for that one transfer.
- A passing checksum proves the string was not mistyped. It does not prove the address belongs to the person you intend to pay.
For what happens after a transfer leaves your wallet, see our explainers on Ethereum transaction receipt status and on why a transaction stays pending. If the worry is what a signature lets a contract do rather than where funds go, start with ERC-20 token allowances.
Reporting & Sources
- ERC-55: Mixed-case checksum address encoding, Ethereum Improvement Proposals, created January 14, 2016 (status Final)
- ERC-1191: Add chain id to mixed-case checksum address encoding, Ethereum Improvement Proposals (status Last Call)
- Ethereum accounts, ethereum.org developer documentation
- Addresses API, ethers.js v6 documentation
- Types: Address Literals, Solidity documentation
- BIP-173: Base32 address format for native v0-16 witness outputs, Bitcoin Improvement Proposals (status Deployed)
- BIP-350: Bech32m format for v1+ witness addresses, Bitcoin Improvement Proposals (status Deployed)
- base58.cpp, Bitcoin Core source code
- ASYA Official calculation and simulation of ERC-55 checks, 20,000 random addresses and 200,000 single-character typos, November 15, 2026





