Wallet Address Checker

Why address format detection matters

Every blockchain defines its own address format — a consequence of different cryptographic choices, encoding schemes, and design philosophies. When you're building a multi-chain wallet, a payment form, a fraud-detection layer, or a data pipeline that ingests user-submitted addresses, you need to know which network an address belongs to before you can do anything useful with it.

Submitting a Solana address to an Ethereum node, or a Bitcoin address to a Solana RPC, will either error silently or produce a nonsensical result. Client-side format detection catches these mistakes at the boundary, before any on-chain call is made.

EVM chains — the 0x prefix family

Ethereum and every EVM-compatible chain (Polygon, BNB Smart Chain, Arbitrum, Optimism, Avalanche C-Chain, Base, etc.) share an identical address format: a 0x prefix followed by 40 lowercase hexadecimal characters, representing 20 raw bytes derived from the last 20 bytes of the Keccak-256 hash of the public key.

0x742d35Cc6634C0532925a3b8D4C9b74b49F1234c

EIP-55 checksum. Ethereum addresses are case-insensitive at the protocol level, but EIP-55 defines a checksum encoding where specific hex letters are capitalized based on the Keccak hash of the lowercase address. A mixed-case address that passes EIP-55 validation has almost certainly been typed or generated correctly — a random corruption of one character almost never produces a valid checksum.

This tool validates EIP-55 when the address contains at least one uppercase letter. A fully lowercase or fully uppercase 0x address is reported as valid (no checksum) but flagged as lacking checksum protection.

Bitcoin — three generations of address format

Bitcoin has evolved through three address formats, all still in active use:

P2PKH (Legacy) — 1… Starts with 1, Base58Check encoded, 25–34 characters. The oldest format, highest fees because scripts are larger. Example: 1A1zP1eP5QGefi2DMPTfTL5SLmv7Divf Na.

P2SH (Script Hash) — 3… Starts with 3, Base58Check encoded. Used for multisig wallets and wrapped SegWit (P2SH-P2WPKH). Slightly ambiguous — a 3… address could be either a multisig or a wrapped SegWit; the chain data resolves which.

Bech32 (Native SegWit) — bc1q… Human-readable part bc, separator 1, then a Bech32-encoded program. Lower fees, stronger error detection (Bech32 can detect and locate up to 4 errors). bc1q addresses are P2WPKH (single key); bc1p addresses (Taproot, BIP-341) are P2TR.

This tool detects all three formats and reports the specific type.

Solana — Base58, 32 bytes

Solana addresses are the Base58 encoding of a 32-byte Ed25519 public key, yielding strings of 32–44 characters. They contain no fixed prefix, which creates an ambiguity: some Solana addresses look superficially similar to Bitcoin Legacy (1… addresses) because both use Base58.

The disambiguation is by length and character set. A valid Solana address is 32–44 Base58 characters (no 0, O, I, or l — those are excluded from Base58). Bitcoin Legacy addresses are 25–34 characters. An address of length 43–44 that is valid Base58 and contains no 0/O/I/l is almost certainly Solana; shorter overlapping lengths require context or an explicit network selector.

Tron — T prefix, Base58Check, 21 bytes

Tron addresses start with T, are Base58Check encoded, and are 34 characters long. Internally Tron uses an EVM-compatible 20-byte address (same derivation as Ethereum), but prepends a 0x41 network byte before encoding. You can convert between a Tron address and its hex equivalent with a Base58Check decode followed by stripping the first byte.

TJCnKsPa7y5okkXvQAidZijX6KgBCjQceC  ← Tron
0x...                                  ← the same key, Ethereum style

Other chains detected

• Litecoin — Legacy L… (P2PKH), M… (P2SH), ltc1… (Bech32)
• Dogecoin — D… (P2PKH)
• XRP (Ripple) — Base58Check with a different alphabet, starts with r
• Cardano — Bech32 with HRP addr1 (shelley) or Ae2… (Byron era)
• Cosmos/ATOM — Bech32 with HRP cosmos1

What this tool does NOT do

This is a format validator, not a chain oracle. It checks:

• Does the string match a known address pattern?
• Does the checksum (EIP-55, Base58Check, Bech32) validate?
• What network(s) is this format consistent with?

It does not:

• Make any RPC or API call to any blockchain node
• Check whether the address exists on-chain or has ever had a transaction
• Verify a balance or token holdings
• Validate a signature or prove key ownership
• Distinguish between mainnet and testnet (testnet addresses often share the same format)

For on-chain state, use a block explorer or a node RPC call after confirming the address format here.

Use cases

Payment form validation. Before submitting a withdrawal, confirm the user-entered address matches the expected network. Sending ETH to a BTC address format will error at the node; sending to the wrong EVM chain (same format, different chainId) silently succeeds and funds are unrecoverable.

Multi-chain wallet UX. Auto-detect which network the user is targeting and pre-select the right chain in the UI.

Fraud detection at ingress. In a KYC or compliance pipeline, flag addresses that don't match any known format — likely typos or intentionally malformed submissions.

Data cleanup. Normalize a mixed CSV of wallet addresses by network before routing to per-chain enrichment services.

Privacy

Address strings are validated locally in the browser using regex patterns and checksum algorithms. No address is transmitted to any server.

Can two different chains use the same address format?

Yes — this is the most important caveat. All EVM-compatible chains (Ethereum, Polygon, Arbitrum, BNB Smart Chain, Base, etc.) share an identical 0x… address format. The same string is a valid address on every EVM chain simultaneously. The tool reports "EVM-compatible" rather than a specific chain because format alone cannot tell them apart. Use the chainId in your application context to disambiguate.

Does a valid checksum mean the address is safe to send funds to?

No. Checksum validation (EIP-55 for Ethereum, Base58Check for Bitcoin, Bech32 for SegWit) only confirms that the address string was not accidentally corrupted in transit. It says nothing about whether the address is controlled by anyone, whether it is a contract, or whether it belongs to the recipient you intend. Always confirm addresses out-of-band before sending large amounts.

Why does my Solana address look like a Bitcoin Legacy address?

Both Bitcoin Legacy and Solana use Base58 encoding without a fixed prefix, so short Solana addresses (32–36 characters) can visually resemble Bitcoin 1… addresses. The tool disambiguates by length and by verifying that the Base58 decodes to exactly 32 bytes (Solana) vs 25 bytes with a version byte and checksum (Bitcoin). If ambiguity remains, the tool reports both possibilities.

What is EIP-55 and why does it matter?

EIP-55 is a checksum encoding for Ethereum addresses where specific hex letters are capitalized based on the Keccak-256 hash of the lowercase address. A mixed-case address that passes EIP-55 has a 1-in-2^40 chance of being produced by random corruption — effectively zero. Always store and display Ethereum addresses in EIP-55 mixed-case form, not all-lowercase or all-uppercase.

Does this tool make any network requests?

No. All validation is done client-side using pattern matching and checksum algorithms. No address is ever sent to a server, a blockchain node, or a third-party API. You can use it offline once the page is loaded.

Can I check testnet addresses?

Testnet addresses usually share the same format as mainnet. Ethereum Sepolia addresses are the same 0x… format; Bitcoin testnet uses m… or n… for P2PKH and tb1… for Bech32. The tool detects both mainnet and testnet patterns and labels them accordingly.

What happens if I paste a contract address?

Smart contract addresses on EVM chains are indistinguishable from externally owned account (EOA) addresses by format alone — both are 20-byte hex strings with an optional EIP-55 checksum. The tool will correctly identify it as a valid EVM address. Whether it is a contract or an EOA requires an eth_getCode RPC call.

Why does the tool say my address is invalid even though I copied it from my wallet app?

The most common reasons: extra whitespace or a newline character got copied along with the address (the tool trims whitespace, but a zero-width space may survive), the address contains a character that looks like a valid hex digit but is a Unicode lookalike (e.g., a Cyrillic "о" instead of Latin "o"), or the address was truncated mid-copy. Try selecting the address text again carefully and copying the full string.