Fundamentals ·

Crypto Address Formats: Bech32, Base58, and 0x

If you have ever copied a crypto address and noticed that Bitcoin addresses start with bc1, Ethereum addresses start with 0x, and Solana addresses appear to be an entirely different language, you are not alone. These differences are not cosmetic. Each address format encodes specific information about the blockchain, the type of transaction it supports, and the error-detection mechanisms protecting your funds.

Understanding address formats is practical knowledge. A single wrong character in a crypto address can send funds into the void permanently. This guide breaks down the major encoding schemes, explains why each blockchain chose its format, and shows you how checksums prevent costly mistakes.

Why Addresses Look Different

A cryptocurrency address is a human-readable representation of a public key or a hash derived from one. The raw cryptographic output is binary data, which is not practical for humans to read, copy, or verify. Different blockchains chose different encoding schemes to convert that binary data into text strings.

These encoding choices reflect trade-offs between:

  • Character set safety -- avoiding characters that look alike (0/O, l/1/I)
  • Error detection -- built-in checksums that catch typos before funds are lost
  • Space efficiency -- shorter addresses are easier to handle
  • Case sensitivity -- lowercase-only formats avoid clipboard confusion

The three dominant encoding families in cryptocurrency are Base58Check, Bech32, and hexadecimal with a 0x prefix. Each emerged from specific design goals at specific moments in blockchain history.

Base58Check: Bitcoin Legacy

Base58Check was one of the first address encoding schemes, introduced by Satoshi Nakamoto with Bitcoin. It uses 58 alphanumeric characters, deliberately excluding characters that cause visual confusion:

  • No zero (0) -- too similar to the letter O
  • No uppercase O (O) -- too similar to zero
  • No lowercase L (l) -- too similar to uppercase I and the number 1
  • No uppercase I (I) -- too similar to lowercase l and the number 1

A Base58Check Bitcoin address looks like this: 1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa

The format includes a version byte at the start and a 4-byte checksum at the end. The version byte tells you the address type: 1 for standard Pay-to-Public-Key-Hash (P2PKH) addresses, 3 for Pay-to-Script-Hash (P2SH) addresses. The checksum is computed by running SHA-256 twice on the payload and appending the first 4 bytes of the result.

This checksum means that if you accidentally mistype a single character, the address will almost certainly fail validation rather than sending funds to a wrong but valid address. The probability of a random typo producing a valid checksum is roughly 1 in 4.3 billion.

Several other blockchains adopted Base58Check because it was proven and familiar:

You can use SafeSeed's Bitcoin Address Validator to check whether a Base58Check address has a valid checksum before sending any transaction.

Bech32: SegWit bc1 Addresses

In 2017, Bitcoin introduced Segregated Witness (SegWit), which needed a new address format. Rather than extending Base58Check, developers created Bech32, defined in BIP173. Bech32 addresses are immediately recognizable because they start with bc1 for Bitcoin mainnet.

A Bech32 address looks like: bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4

Bech32 made several deliberate improvements over Base58Check:

Lowercase only

Bech32 uses only lowercase letters and numbers. This eliminates case-sensitivity problems when addresses are transmitted verbally, printed in mixed-case fonts, or encoded in QR codes (which are more compact with single-case data).

Superior error detection

Base58Check detects errors but cannot tell you where the error is. Bech32 uses a BCH code (Bose-Chaudhuri-Hocquenghem error-correcting code) that can detect any single-character error and most multi-character substitution errors. It can identify the position of up to two errors, enabling potential correction in some wallet interfaces.

Smaller QR codes

Because Bech32 uses a restricted character set (32 characters), QR codes representing these addresses are measurably smaller and easier to scan.

Bech32m

An updated version called Bech32m (BIP350) fixed a minor weakness in the original Bech32 format related to the final character. Modern SegWit v1 addresses (Taproot, starting with bc1p) use Bech32m. If you generate a Bitcoin address with SafeSeed's Bitcoin Address Generator, the default output uses the modern Bech32/Bech32m format.

Litecoin also adopted Bech32 for its SegWit addresses, using the ltc1 prefix.

0x: EVM Chain Addresses

Ethereum took a completely different approach. Ethereum addresses are 20-byte values displayed as 40 hexadecimal characters with a 0x prefix:

0x742d35Cc6634C0532925a3b844Bc9e7595f2bD08

The hex format is straightforward: each byte maps to two hex characters (0-9, a-f). This makes the address a direct representation of the underlying data without any special encoding.

EIP-55 mixed-case checksum

The original Ethereum address format had no built-in checksum. If you mistyped a character, the address was still technically valid, and your funds would be lost. EIP-55 solved this by using the capitalization of hex letters as a checksum. The address is hashed with Keccak-256, and each letter is capitalized if the corresponding nibble in the hash exceeds 8.

This is why you see Ethereum addresses with seemingly random capitalization. The mixing of upper and lowercase letters is not arbitrary; it is a checksum. If you change a single character, the capitalization pattern will not match, and a properly implementing wallet will reject it.

Shared across EVM chains

One of the most significant aspects of the 0x format is that it is identical across all EVM-compatible chains:

The same private key produces the same address on all of these chains. This is both a convenience and a source of confusion: sending tokens to the right address on the wrong chain is a common mistake. For a deeper look at EVM address security, see our guide on EVM Address Security.

You can validate any EVM address, including its EIP-55 checksum, with SafeSeed's Ethereum Address Validator.

Base58 in Solana, XRP, and TRON

Several modern blockchains use Base58 encoding but without the Check suffix, meaning they implement their own checksum or validation mechanisms.

Solana

Solana addresses are Base58-encoded Ed25519 public keys, typically 32 to 44 characters long:

7EcDhSYGxXyscszYEp35KHN8vvw3svAuLKTzXwCFLtV

Solana uses the same Base58 alphabet as Bitcoin (excluding the visually confusing characters) but does not append a version byte or a SHA-256 checksum. Instead, the address is simply the raw public key in Base58 encoding. Validation depends on the key being a valid point on the Ed25519 curve. SafeSeed's Solana Address Validator handles this verification.

XRP

XRP uses Base58Check encoding with its own version prefix, producing addresses that start with r:

rN7n3473SaZBCG4dFL83w7p1W9cgZw6p1N

TRON

TRON addresses use Base58Check with a 0x41 version byte, producing addresses that start with T:

TJCnKsPa7y5okkXvQAidZBzqx3QyQ6sxMW

Interestingly, TRON uses the same secp256k1 elliptic curve as Ethereum and Bitcoin. A TRON address is derived from the same key material as an Ethereum address but encoded differently.

Checksums: Your Safety Net

A checksum is a small piece of data derived from the address payload that lets software detect errors. Think of it as a mathematical fingerprint: if even one character changes, the fingerprint will not match.

Here is how checksum mechanisms compare across the major formats:

Format Checksum Method Detection Capability
Base58Check Double SHA-256 (4 bytes) Detects virtually all errors
Bech32 BCH code (6 characters) Detects all single-character errors; locates up to 2 errors
EIP-55 (0x) Keccak-256 capitalization ~99.98% error detection for single-character changes
Solana Base58 Ed25519 curve validation Rejects invalid curve points

The checksum does not protect against every type of mistake. If malware replaces your entire clipboard with a different valid address (a clipboard hijacking attack), the checksum will still pass because the attacker's address is itself valid. Checksums protect against accidental typos and transmission errors, not deliberate fraud.

For a broader look at threats beyond typos, see Common Crypto Scams Involving Seed Phrases.

Validating Addresses Before Sending

Every cryptocurrency transaction should begin with address validation. This means more than glancing at the first few characters. Proper validation includes:

1. Format verification

Confirm the address matches the expected format for the blockchain you are using. A bc1 address should only be used on Bitcoin. An 0x address could be valid on multiple EVM chains, so double-check which network you intend to use.

2. Checksum verification

Run the address through a validator that checks the built-in checksum. SafeSeed provides free validators for the most common chains:

All validation runs entirely in your browser using client-side code. No address data is transmitted to any server.

3. Visual confirmation

Even after automated validation, visually confirm the first and last several characters of the address. Clipboard hijacking malware sometimes replaces addresses with attacker-controlled ones that share the same first few characters.

4. Small test transaction

For large transfers, send a small amount first and confirm receipt before sending the full balance. The minor transaction fee is a small price for certainty.

5. Use address book features

Most wallets allow you to save validated addresses. Once you have confirmed an address, save it to avoid re-entering it (and introducing new opportunities for error).

For a detailed walkthrough of the validation process, see How to Validate a Crypto Address.

Choosing the Right Format

If you are generating new addresses, modern formats are almost always preferred:

  • Bitcoin: Use Bech32 (bc1) addresses for lower fees and better error detection. Legacy Base58Check addresses still work but cost more in transaction fees due to larger transaction sizes.
  • Ethereum and EVM chains: Always use EIP-55 checksummed addresses. Most modern tools produce these by default.
  • Solana: Base58 is the only option, and it works well.

When generating addresses with SafeSeed, the tools default to the most current and secure format for each blockchain. Whether you use the Bitcoin Seed Phrase Generator or the Ethereum Address Generator, the derived addresses will use the recommended encoding for that chain.

Understanding these formats removes the mystery from cryptocurrency addresses. They are not random strings -- they are carefully engineered representations of cryptographic keys, with built-in safety mechanisms designed to protect your funds from simple human error.