Ethereum Address Validator
ValidatorValidate Ethereum addresses and verify their EIP-55 mixed-case checksum. Detects typos in checksummed addresses instantly. Runs entirely in your browser.
Ethereum addresses are 0x followed by 40 hex characters. Without a checksum, an all-lowercase (or all-uppercase) address carries no built-in error detection. EIP-55 fixes this by capitalizing letters based on a Keccak-256 hash of the address, so the exact same 40 characters — now mixed-case — become self-verifying.
| Form | Meaning | Example |
|---|---|---|
| All one case | Valid, but no checksum — typos aren't detected | 0xd8da6bf2... |
| EIP-55 mixed-case | Capitalization encodes a Keccak-256 checksum | 0xd8dA6BF2... |
About this tool
About Ethereum Address Validator
An Ethereum address is the last 20 bytes of the Keccak-256 hash of a public key, displayed as 40 hexadecimal characters prefixed with 0x. Unlike Bitcoin, Ethereum addresses have no built-in checksum in their raw hex form — an all-lowercase or all-uppercase address carries no error-detection at all. EIP-55 fixes this by encoding a checksum into the capitalization of the letters themselves, so the address stays valid hex while also detecting typos.
This validator checks that an address is 0x followed by exactly 40 hex characters, then evaluates its casing. All-lowercase or all-uppercase addresses are valid but carry no checksum information. Mixed-case addresses are checked against the EIP-55 checksum: the address is lowercased, hashed with Keccak-256, and each letter is re-capitalized based on the corresponding nibble of the hash — if that doesn't match the input exactly, the address is flagged as an invalid checksum, most likely a typo. The Keccak-256 implementation is written from scratch in this validator, since it isn't NIST SHA3-256 (different padding) and isn't available via the browser's Web Crypto API.
Validate Ethereum addresses before sending a transaction, in wallet and dApp frontends, in smart contract test fixtures, in exchange withdrawal forms, and in any backend that accepts user-submitted addresses and wants to catch copy-paste errors before they become an on-chain mistake.
Instant validation with no network requests — Keccak-256 and the EIP-55 checksum are both computed entirely client-side. The validator distinguishes between an address with no checksum (all one case) and one that fails its checksum (mixed case that doesn't match), and always shows the correct checksummed form for reference.
Key Features
- Validates 0x + 40 hex character format
- EIP-55 mixed-case checksum verification
- Detects all-lowercase / all-uppercase addresses (no checksum present)
- Shows the correct checksummed form for any valid address
- Keccak-256 implemented natively — no external crypto library
- 100% browser-based, no data leaves your device
FAQ
Ethereum Address Validator — Frequently Asked Questions
What is an Ethereum address?
An Ethereum address is derived from a public key: the key is hashed with Keccak-256, and the last 20 bytes (40 hex characters) of that hash become the address, written with a 0x prefix. It represents an account — either a wallet controlled by a private key (EOA) or a smart contract.
What is EIP-55 and why does it matter?
EIP-55 is the Ethereum Improvement Proposal that defines a mixed-case checksum for addresses. Because a raw hex address has no error-detection, a single mistyped character still looks like a valid address — potentially sending funds to the wrong (or no) account. EIP-55 encodes a checksum into the capitalization of each letter, so a typo almost always breaks the checksum and gets caught before you send anything.
How is the EIP-55 checksum calculated?
Lowercase the address (without 0x) and compute its Keccak-256 hash. Then walk through each character of the address: if it's a letter (a-f) and the corresponding hex digit of the hash is 8 or greater, capitalize it; otherwise leave it lowercase. Digits (0-9) are never changed. The result is the checksummed address.
Why is an all-lowercase or all-uppercase address still 'valid'?
All-lowercase and all-uppercase addresses predate EIP-55 and remain valid — wallets and contracts still accept them. They simply carry no checksum information, so a typo in one of those addresses would not be detected by casing alone. This validator flags them as valid but without checksum verification, rather than as invalid.
Is Keccak-256 the same as SHA3-256?
No. Keccak-256 is the original Keccak algorithm submitted to the NIST SHA-3 competition, using the simple pad10*1 padding. When NIST standardized SHA-3, it added a domain-separator suffix before that padding, producing different output for the same input. Ethereum uses the original, pre-standardization Keccak-256 — which is why a generic SHA3-256 function (including the browser's Web Crypto API, which doesn't expose SHA-3 at all) can't be substituted here.
Tips
- Always double-check a mixed-case address's checksum before sending funds — a single flipped letter can indicate a typo
- If an address is all-lowercase, ask the source for the checksummed version when possible to enable typo detection
- Smart contract addresses use the same 0x + 40 hex format and the same EIP-55 checksum as wallet addresses
- This validator never sends your address anywhere — the checksum is computed entirely in your browser
Explore more
Related Tools
Other tools that might be useful for your workflow