Ethereum Address Checksum

Validate and convert Ethereum addresses to EIP-55 checksum format. Supports batch processing for multiple addresses.

EIP-55 Checksum Converter

Ethereum Address

What the Ethereum Address Checksum tool does

An Ethereum address is 20 bytes — 40 hex characters with a 0x prefix. The byte values are case-insensitive; the protocol treats 0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed and 0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAedas the same account. EIP-55 adds a checksum by selectively capitalising hex letters: hash the lowercase address with Keccak-256, and for each character whose nibble in the hash is ≥ 8, uppercase it. The result is a mixed-case string that catches roughly 99.98% of single-character typos.

Paste an address (any case) and the tool returns the canonical EIP-55 form. Paste a list and it processes them in bulk. The output is what every block explorer and most modern wallets display — and what some smart contracts (notably token transfer front-ends) require before allowing a paste-and-send.

EIP-55 is also the canonical form for ENS reverse records, EIP-712 typed data, and anywhere else an address must be stable across systems. If your indexer compares addresses as strings rather than bytes, normalising to EIP-55 prevents duplicate rows for the same account.

A scenario where this matters

A customer support agent copies a wallet address from a user's Telegram message into a spreadsheet of refund recipients. The pasted text contains a stray Unicode zero-width space or a homoglyph (a Cyrillic letter that looks like a Latin one). When the agent later pastes the address into MetaMask, the wallet shows Invalid address. Run the address through this tool — it strips invisible characters, validates the hex, and returns the EIP-55 form. The validity check confirms the bytes are real before any money moves. Two seconds of paranoia versus a funds-sent-to-wrong-address ticket.

How to use

Enter a single Ethereum address (starting with 0x) in the input field, or toggle batch mode to process multiple addresses at once.
Click Convert to generate the EIP-55 checksum address.
The tool validates the address format and displays the checksum result along with its validity status.
In batch mode, enter one address per line. All addresses are converted simultaneously; invalid lines are flagged.
Use the Copy button to copy the result to your clipboard.

EVM chains covered

Sample inputs that this tool processes correctly. Paste any of these into the editor above to see a valid decode; shapes that do not match these patterns are rejected before any calculation.

Chain / family	Sample	Format
Ethereum	0x742d35Cc6634C0532925a3b844Bc9e7595f8f12a	hex, 20 bytes, EIP-55 checksum
Polygon	0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48	hex, same as Ethereum
Arbitrum	0xB0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48	hex, same as Ethereum

Deep dive: how the EIP-55 algorithm works

Step by step

Strip the 0x prefix and lowercase the hex string.
Compute Keccak-256 of the ASCII bytes of that lowercase string.
For each character in the address: if it is a letter (a-f), uppercase it when the corresponding hex nibble in the hash is ≥ 8 (i.e. 8, 9, a, b, c, d, e, or f).
Digits 0-9 are never changed.
Re-attach the 0x prefix.

Why Keccak-256, not SHA3-256

Ethereum predates the NIST SHA-3 standardisation. The hash everyone calls "keccak256" in Solidity is the original Keccak submission with a different padding rule than final SHA3-256. This matters when you re-implement EIP-55 from scratch in a language where "sha3" means the standardised SHA-3 — the results differ. Use a library that exposes the original Keccak (most ETH libraries do).

EIP-1191: chain-specific checksums

A later proposal, EIP-1191, prepends chainId-0xto the lowercase address before hashing. RSK adopted it; Ethereum mainnet did not. The result is that an EIP-1191 address from RSK looks like an EIP-55 address from Ethereum but has different uppercase positions. This is why pasting an RSK address into an Ethereum-only checker sometimes shows "invalid checksum" even though the bytes are fine — and why most modern tools (including this one) only validate EIP-55 by default.

Quick reference: EIP-55 in practice

Form	Example	When you see it
All lowercase	0x5aaeb6053f3e94c9...	Output of ethers v6 decoding, raw RPC responses, ABI-decoded addresses.
EIP-55 checksum	0x5aAeb6053F3E94C9...	Etherscan, MetaMask, wallet UIs, ENS records.
All uppercase	0X5AAEB6053F3E94C9...	Rare; some legacy explorers. Treated as "no checksum" by validators.
Random mixed case	0x5AaeB6053f3E94...	Probably a typo. Will fail EIP-55 validation.

Common pitfalls

Comparing addresses with string equality. 0x5aaeb6... and 0x5aAeb6... are the same account but different strings. Normalise to a single case (lowercase or EIP-55) before comparing, or compare as bytes.
Storing addresses with random capitalisation in a database. Indexes treat strings literally. Two rows with the same address but different cases cause double-counting. Always store EIP-55 or always lowercase.
Trusting an "invalid checksum" warning blindly. A lowercase address has no checksum, so it cannot be invalid — only validated or not. Reject only addresses that have mixed case but fail EIP-55.
Forgetting EIP-1191 exists.If your dApp supports RSK, BSC's chain-bound checksum, or Polygon zkEVM's, you need a checksum library that knows about chainId. Plain EIP-55 will reject valid addresses from those chains.
Pasting addresses with hidden Unicode. Right-to-left override characters and zero-width spaces survive copy/paste. They invalidate the hex check but are invisible to humans. Strip non-ASCII before validating.
Confusing "checksum valid" with "address exists." EIP-55 only confirms the typing is consistent; it tells you nothing about whether the address has ever been used, is a contract, or holds funds. That requires an RPC call.

EIP-55 Checker vs ethers / viem / Etherscan

This tool: paste-and-convert. Batch mode for a list of addresses. No SDK install, no network calls.
ethers.getAddress(addr): returns the EIP-55 form; throws on invalid. Identical algorithm; the right answer inside production code.
viem.getAddress(addr): same idea, slightly different error shapes.
Etherscan search: auto-displays the EIP-55 form when you look up an address. Not really a checker — more of a side effect. Inconvenient for bulk work.
Solidity address(uint160(...)): on-chain conversion is cheap and case-blind; the EIP-55 check belongs in front-end code, not in contracts.

Real-world integration

When importing a CSV of recipient addresses for an airdrop, run every row through this tool first. The batch mode flags rows that are not 42 chars, contain non-hex characters, or fail an existing checksum. This catches manual transcription errors before the airdrop contract is deployed with a baked-in recipient list.

For cross-chain dApps, paste your EVM address here and the canonical form here, then use the Ethereum Address Checksum to derive the corresponding bech32 or other-chain form. The two-step flow gives you a verified Ethereum address plus the matching Cosmos- or Kaia-style address without risking a typo at either step.

For Merkle-based allowlists used in NFT launches, every leaf is an EIP-55 address (sometimes plus an extra field). Inconsistent capitalisation produces a different leaf hash, breaks the proof, and reverts the mint. Always normalise allowlist inputs with this tool before passing them to the Ethereum Address Checksum.

When NOT to use this tool

You are validating non-EVM addresses (Solana, Bitcoin, Cosmos). Each chain has its own format and checksum scheme. Use the matching validator.
You need to check whether an address has activity. EIP-55 says nothing about state. Query the chain's RPC for balance, nonce, or code.
You are working with EIP-1191 chain-specific checksums (RSK and a handful of others). Plain EIP-55 will reject those even when correct.
You need to identify the type of account (EOA vs contract). EIP-55 treats both the same. Use eth_getCode to distinguish.

Troubleshooting

"Invalid address" on a string that looks fine: count the characters. An EVM address must be exactly 42 chars (including 0x). Stray spaces, newlines, or zero-width Unicode invalidate it.
"Invalid checksum" on a known good address: someone has probably edited the case manually. Re-derive the EIP-55 form from the lowercase version.
Address differs from Etherscan's display: verify the network. The same hex address on different chains has the same EIP-55 form, but RSK and a few other chains use EIP-1191, which produces different capitalisation.
ENS name does not resolve to the address you expect: EIP-55 has no effect on ENS resolution — ENS resolves by lowercase hash. The displayed checksum form is only for UI consistency.

Key features

EIP-55 conversion using the original Keccak-256 (not SHA3-256).
Batch mode for converting a newline-separated list of addresses.
Invalid-format detection (length, hex chars, hidden Unicode).
Checksum validation for already-cased addresses.
Works for any EVM chain (Ethereum, Polygon, BSC, Arbitrum, Optimism, Base, ...).
Runs 100% client-side. Addresses never leave the browser tab.

Frequently asked questions

What happens if I enter an invalid Ethereum address?

The tool validates that the address is exactly 42 characters long (including the 0x prefix) and contains only valid hex characters (0-9, a-f, A-F). If the address is invalid, an error message is displayed. Stray whitespace, hidden Unicode, and Cyrillic homoglyphs are common causes — the tool strips and reports them.

Can a checksummed address prevent sending to a wrong address?

EIP-55 checksums detect random typos with approximately 99.98% probability. If you accidentally change a character, the mixed-case checksum validation fails, alerting you before sending funds. It cannot protect against deliberately crafted addresses (vanity addresses or address poisoning) that satisfy the checksum by design.

What is the difference between a checksummed and non-checksummed address?

A non-checksummed address is all lowercase (e.g. 0x5aaeb6053f3e94c9b9a09f33669435e7ef1beaed). A checksummed address uses mixed case based on the Keccak-256 hash of the lowercase form (e.g. 0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed). Both refer to the same account; only one carries error-detection.

Can I use this tool to validate contract addresses?

Yes. EIP-55 applies to all 20-byte EVM addresses, including externally owned accounts (EOAs) and smart contract addresses. The checksum format does not distinguish between them — that distinction requires an RPC call to eth_getCode.

Does this tool support other blockchain networks?

EIP-55 works for any EVM chain that uses the standard 20-byte address (Polygon, BSC, Arbitrum, Optimism, Avalanche C-Chain, Base, Linea, and most other L2s/L3s). It does not work for RSK and a small handful of chains that use EIP-1191 chain-bound checksums.

How does the EIP-55 algorithm work internally?

Take the lowercase hex address (without 0x), compute its Keccak-256 hash, then iterate through each character. If the character is a letter (a-f) and the corresponding nibble in the hash is ≥ 8 (0x8-0xF), uppercase it. Otherwise leave it. Digits 0-9 are never changed. Re-attach the 0x.

Why is the same address sometimes lowercase and sometimes mixed case in my logs?

Most ethers v6 return paths produce lowercase by default. Etherscan and most wallet UIs display EIP-55. If your indexer ingests both, normalise to one form before storing — typically EIP-55 for display, lowercase for keys.

Related guides

Ethereum for Developers: Addresses, Checksums, and Key Concepts

Everything you need to start shipping on Ethereum: EIP-55 address checksums, wei-to-ether math, gas mechanics, wallet derivation, and the Hardhat vs Foundry split.

Related Tools

Crypto Unit Converter

Convert between ETH, Wei, Gwei, BTC, and Satoshi units.

Wei / Gwei / Ether Converter

Convert between Wei, Gwei, and Ether with decimal precision.

Ethereum for Developers: Addresses, Checksums, and Key Concepts12 min read