Introduction
Sending cryptocurrency to a mistyped address is irreversible. There is no bank to reverse the transaction, and the funds are gone permanently. That is why every major cryptocurrency embeds a checksum in its addresses. Bitcoin uses Base58Check or Bech32, Ethereum uses EIP-55 mixed-case encoding, and Tron uses a 21-byte Base58Check payload. This validator auto-detects the cryptocurrency from the address format, verifies the checksum, and reports the address type and network (mainnet or testnet). Paste an address above and the result appears instantly. Nothing is sent to a server.
What this tool does
- Auto-detects the cryptocurrency from the address format and validates it: Bitcoin, Ethereum, Litecoin, Dogecoin, Tron, and Solana.
- Verifies Bitcoin Base58Check addresses (P2PKH with 1-prefix, P2SH with 3-prefix, testnet with m/n-prefix) by decoding the payload and checking the 4-byte double SHA-256 checksum.
- Validates Bitcoin and Litecoin Bech32 and Bech32m SegWit addresses (bc1, tb1, ltc1, tltc1 prefixes), distinguishing P2WPKH (20-byte program), P2WSH (32-byte program), and Taproot P2TR (32-byte v1 program).
- Checks Ethereum addresses against the EIP-55 mixed-case checksum, reporting whether the address has a checksum and whether it matches.
- Validates Tron 34-character Base58Check addresses (T-prefix, version byte 0x41) and Dogecoin addresses (D-prefix P2PKH, 9-prefix P2SH).
- Identifies Solana addresses as 32-byte ed25519 public keys in Base58, noting that Solana addresses have no checksum to validate.
How this tool works
Paste a cryptocurrency address into the input field. The tool trims whitespace and runs it through a detection chain that tries each supported format in order.
For Ethereum, it checks the pattern `0x` followed by 40 hex characters. If the address contains mixed case, the tool computes the EIP-55 checksum by hashing the lowercase address with Keccak-256 and comparing the case of each hex letter against the hash output. If all letters are lowercase or all uppercase, there is no checksum to verify, and the tool notes this.
For Bitcoin, the tool checks for Bech32 prefixes (bc1, tb1, bcrt1) first. It decodes the Bech32 or Bech32m checksum, extracts the witness version and program, and classifies the address as P2WPKH, P2WSH, or P2TR based on the program length and witness version. If no Bech32 prefix is found, it tries Base58Check decoding, which verifies the 4-byte checksum appended after the payload (a double SHA-256 hash of the version byte plus payload).
For Litecoin, it checks both Bech32 (ltc1, tltc1) and Base58Check (L-prefix P2PKH, M-prefix P2SH). For Dogecoin, it checks Base58Check with D-prefix and 9-prefix. For Tron, it checks 34-character T-prefix Base58Check with version byte 0x41. For Solana, it checks Base58 with 32-44 character length and notes that no checksum exists.
The settings panel shows the detected currency, address type, network, and checksum status.
How cryptocurrency address checksums work
Cryptocurrency addresses use several different checksum schemes, each designed to catch transcription errors before funds are sent to an invalid destination.
Base58Check is the original Bitcoin address format, described in the Bitcoin Wiki Base58Check article. It takes a version byte (0x00 for mainnet P2PKH, 0x05 for P2SH), appends the 20-byte hash160 of the public key, computes a 4-byte checksum as the first four bytes of SHA-256(SHA-256(version + payload)), and encodes the whole thing in Base58. The checksum catches any single-character substitution and most transpositions. The Base58Check Encoder provides standalone encoding and decoding with checksum inspection.
Bech32 was introduced in BIP 173 for SegWit addresses. It uses a 32-character alphabet (excluding 1, b, i, o to avoid confusion) and a BCH error-correcting code that guarantees detection of up to 4 character substitutions and up to 3 transpositions. Bech32 was later found to have a weakness where a single-character insertion at the end of the HRP could pass the checksum. BIP 350 introduced Bech32m, which changes the checksum constant from 1 to 0x2bc830a3 and is used for Taproot (witness version 1) addresses. SegWit v0 addresses still use Bech32, while v1+ uses Bech32m.
Ethereum addresses are 20-byte values shown as 40 hex characters with a 0x prefix. EIP-55 defines a mixed-case checksum: the lowercase hex address is hashed with Keccak-256, and each hex letter in the address is capitalized if the corresponding nibble in the hash is 8 or higher. This produces a checksum that catches case errors without adding length. The Ethereum Checksum Validator provides standalone EIP-55 verification.
Solana addresses are 32-byte ed25519 public keys encoded in raw Base58 with no checksum. This means a Solana address cannot be validated for integrity, only for format. You must verify Solana addresses through other means (QR codes, address book entries) before sending funds. The Bitcoin Address Generator shows how Bitcoin addresses are constructed from public keys.
How to use this tool
- Paste a cryptocurrency address into the input field. The tool auto-detects the currency from the format, so you do not need to select it manually.
- Check the Valid indicator at the top of the settings panel. An invalid address will show the reason (bad checksum, wrong length, unknown format).
- Review the detected currency, address type (P2PKH, P2SH, P2WPKH, P2WSH, P2TR, EOA, ed25519 public key), and network (mainnet or testnet).
- For Ethereum, check whether the address has a mixed-case checksum. All-lowercase or all-uppercase addresses have no checksum and cannot be verified for integrity.
- For Bitcoin and Litecoin Bech32 addresses, the witness version and program length determine the address type. v0 with 20 bytes is P2WPKH, v0 with 32 bytes is P2WSH, v1 with 32 bytes is P2TR (Taproot).
- For Solana, note that the checksum status shows N/A because Solana addresses have no embedded checksum.
Real-world examples
Verifying a Bitcoin Taproot address
Input: `bc1p5d7rjq7g6rdk2yhzks9smlaqtedr4dekq08le8p8qxfwcgl0e3n7s4q52c`. The tool detects the `bc1` prefix, decodes the Bech32m checksum (witness version 1 requires Bech32m per BIP 350), extracts the 32-byte program, and classifies it as P2TR (Taproot). The checksum is valid, confirming the address was transcribed correctly. If a single character is changed, the Bech32m checksum fails and the tool reports an invalid address.
Catching a bad EIP-55 checksum on an Ethereum address
Input: `0x5aAebae527B876a5C7D4c77F4E3A2F1dE5C7B2E1`. The tool detects the 0x + 40 hex pattern and computes the EIP-55 checksum by hashing the lowercase address with Keccak-256. If the case of any hex letter does not match the hash output, the tool reports "EIP-55 checksum not matched." This catches the case where someone manually typed an address and got the capitalization wrong, which would still send to a valid address but indicates a potential transcription error.
Identifying a Tron address and its version byte
Input: `TJRabPrwbZy45sbavfcjinPJC18kjpRTv8`. The tool detects the T-prefix and 34-character Base58Check format, decodes the payload to 21 bytes, and checks that the version byte is 0x41 (Tron mainnet). The checksum (double SHA-256 of the first 17 bytes) is verified. The tool reports the address as a valid Tron mainnet address with a 20-byte hash160 payload, which is the same structure as a Bitcoin P2PKH address but with a different version byte.
Recognizing a Solana address with no checksum
Input: `7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsU`. The tool detects a 44-character Base58 string in the Solana length range (32-44 chars). Because Solana addresses are raw ed25519 public keys with no checksum, the tool reports the address as valid format but notes "Solana addresses have no checksum to validate." This means you cannot detect transcription errors mathematically and must verify the address through other means before sending funds.
Comparison with similar methods
| Method | Complexity | Typical use |
|---|---|---|
| Base58Check (Bitcoin, Litecoin, Dogecoin, Tron) | 4-byte double SHA-256 checksum, 26-35 chars | Legacy Bitcoin addresses, Tron, Dogecoin |
| Bech32 (BIP 173, SegWit v0) | BCH error-correcting code, detects 4 substitutions | Bitcoin and Litecoin SegWit v0 addresses |
| Bech32m (BIP 350, SegWit v1+) | BCH code with constant 0x2bc830a3 | Bitcoin Taproot (P2TR) addresses |
| EIP-55 (Ethereum) | Keccak-256 mixed-case checksum, no length overhead | Ethereum and EVM-compatible addresses |
| Raw Base58 (Solana) | No checksum, 32-byte ed25519 public key | Solana account addresses |
Limitations or considerations
This tool validates address format and checksum integrity. It does not verify that the address exists on the blockchain, that it has a non-zero balance, or that it belongs to the intended recipient. A valid Bitcoin address with a correct checksum can still be an unused address that nobody controls.
Solana addresses have no checksum, so the tool can only verify the format (Base58, 32-44 characters). It cannot detect transcription errors in Solana addresses. Always verify Solana addresses through a QR code or address book entry before sending funds.
The tool does not validate addresses for every cryptocurrency. It supports Bitcoin, Ethereum, Litecoin, Dogecoin, Tron, and Solana. Other chains (Cardano, Polkadot, Near, Aptos, Sui) use different address formats and checksums that are not handled here.
EIP-55 checksums only work when the address contains mixed case. An all-lowercase Ethereum address (common in code and some wallet UIs) has no checksum to verify. The tool will report it as valid format but note that the checksum was not matched. For standalone EIP-55 verification and conversion, use the Ethereum Checksum Validator.
Frequently asked questions
What is the difference between Bech32 and Bech32m?
Bech32 was defined in BIP 173 for SegWit v0 addresses. Bech32m was defined in BIP 350 for SegWit v1 and later (Taproot). The only difference is the checksum constant: Bech32 uses 1, Bech32m uses 0x2bc830a3. The change was made because Bech32 had a weakness where inserting a character at the end of the HRP separator could pass the checksum. SegWit v0 addresses still use Bech32, while v1+ uses Bech32m.
Why do Ethereum addresses sometimes have mixed case?
EIP-55 defines a mixed-case checksum for Ethereum addresses. The lowercase address is hashed with Keccak-256, and each hex letter is capitalized if the corresponding nibble in the hash is 8 or higher. This creates a checksum without adding length. Wallets display mixed-case addresses to allow verification, but many APIs and code samples use all-lowercase for convenience, which has no checksum.
Can this tool tell me if an address has a balance?
No. This tool only validates the format and checksum. It does not query the blockchain. To check a balance, you need a blockchain explorer or an API call to a node. A valid address with a correct checksum may have zero balance or may never have been used on the network.
Why can Solana addresses not be validated for transcription errors?
Solana addresses are 32-byte ed25519 public keys encoded in raw Base58 with no appended checksum. The format was designed for compactness, not error detection. Unlike Bitcoin (which appends a 4-byte checksum) or Ethereum (which uses EIP-55 mixed case), Solana has no mechanism to detect a mistyped character. You must verify Solana addresses through QR codes or trusted address books before sending.
What is a witness version in a Bech32 address?
The witness version is the first byte after the Bech32 HRP separator. Version 0 indicates SegWit (P2WPKH for 20-byte programs, P2WSH for 32-byte programs). Version 1 with a 32-byte program indicates Taproot (P2TR). Higher versions are reserved for future upgrades. The witness version determines whether Bech32 or Bech32m checksum is used.
Conclusion
Cryptocurrency address validation is the last check before an irreversible transfer. Base58Check, Bech32, Bech32m, and EIP-55 each embed a checksum that catches the transcription errors responsible for most lost funds. This validator auto-detects the currency and verifies the checksum in your browser, so you can confirm an address before clicking send. For deeper inspection of individual formats, see the Base58Check Encoder, the Ethereum Checksum Validator, or the Bitcoin Address Generator.