A wallet address is a public identifier on a blockchain to which cryptocurrency or tokens can be sent, usually a string of letters and numbers derived from a public key or a script. In wallets & custody, the address is the part that is safe to share, while the private key behind it decides who can actually spend the funds it holds.
An address is often compared to a bank account number, but the analogy is incomplete. No institution issues it: a wallet generates addresses locally from cryptographic keys, and a single wallet can create thousands of them. Whoever controls the corresponding private key, whether the user in self-custody or a provider in a custodial wallet, controls the coins.
How a wallet address is derived
Address creation follows a one-way chain of transformations. A wallet starts with a randomly generated private key, computes the matching public key using elliptic curve cryptography, hashes that public key and finally encodes the result in a human-readable format with a checksum that catches typing errors.
- Generate a 256-bit private key, typically derived from a seed phrase.
- Compute the public key on the secp256k1 elliptic curve, used by both Bitcoin and Ethereum.
- Hash the public key, for example with SHA-256 followed by RIPEMD-160 on Bitcoin or Keccak-256 on Ethereum.
- Encode the hash with a network-specific format and checksum, such as Base58Check, Bech32 or hexadecimal.
Each step is easy to compute forward and practically impossible to reverse. Knowing an address reveals nothing usable about the private key, which is why addresses can be published openly on invoices, websites or donation pages.
Modern wallets follow the hierarchical deterministic design described in BIP 32 and related standards. A single seed phrase produces a tree of key pairs through numbered derivation paths, so a wallet can show a fresh receiving address for every payment while a backup of twelve or twenty-four words still restores all of them.
Address formats on major networks
Each blockchain defines its own address formats, and some networks have several. The prefix of an address usually reveals its type, which matters because formats differ in fees, features and compatibility with older software.
| Format | Network | Typical prefix | Key property |
|---|---|---|---|
| Legacy P2PKH | Bitcoin | 1 | Original format, larger transactions |
| P2SH | Bitcoin | 3 | Pays to a script, used for multisig |
| Native SegWit | Bitcoin | bc1q | Bech32 encoding, lower fees, lowercase only |
| Taproot | Bitcoin | bc1p | Bech32m encoding, flexible spending conditions |
| Account address | Ethereum and compatible chains | 0x | 40 hexadecimal characters, optional mixed-case checksum |
| Base58 public key | Solana | No fixed prefix | Encodes the public key directly |
On Ethereum the address is the last 20 bytes of the Keccak-256 hash of the public key. The EIP-55 standard adds a checksum by capitalizing some letters, so wallets can detect most typing errors even though the address remains valid in all lowercase.
Format compatibility still matters in practice. Most current wallets and exchanges can send to all Bitcoin formats, but some older services reject bc1 addresses, and a few platforms support only selected networks for a given token. Before sharing an address, the recipient should confirm that the sender’s platform supports both the format and the network.
Wallet address compared with related concepts
The address is only one element of a wallet. Confusing it with keys or the seed phrase is a frequent and costly misunderstanding, because some of these elements are safe to share and others must never leave the owner’s control.
| Element | Purpose | Safe to share |
|---|---|---|
| Wallet address | Receives funds | Yes |
| Public key | Verifies signatures | Generally yes, with minor privacy cost |
| Private key | Signs transactions that spend funds | Never |
| Seed phrase | Backs up and restores all keys | Never |
| Extended public key | Derives all receiving addresses of an account | Only with trusted services, since it reveals history |
| Crypto wallet | Software or device that manages keys | Not applicable |
Smart contract wallets and multisig wallets add another layer: their addresses belong to code rather than to a single key, and spending depends on rules such as two-of-three signatures. The address looks the same from outside, but the control logic behind it is very different.
Using wallet addresses safely
Sending to the wrong address is usually irreversible, because blockchains have no central party that can recall a confirmed transaction. Safe practice therefore focuses on verifying the address before every transfer.
| Risk | How it happens | Protection |
|---|---|---|
| Clipboard hijacking | Malware swaps a copied address | Check several characters after pasting |
| Address poisoning | Lookalike address planted in transaction history | Never copy addresses from history |
| Wrong network | Token sent on an unsupported chain | Confirm network and token standard |
| Typing errors | Manual entry mistakes | Use QR codes and checksum formats |
| Address reuse | Same address used for many payments | Generate a fresh address for each receipt |
Hardware wallets provide the strongest check: they display the receiving or destination address on their own screen, which malware on the computer cannot alter. A small test transaction before a large transfer remains a sensible habit, especially for first payments to a new counterparty.
Some networks also support human-readable names that resolve to addresses, such as Ethereum Name Service domains. They reduce typing errors but add a resolution step that must be trusted, so the resolved address should still be checked before a large payment.
Privacy and address reuse
Blockchains are pseudonymous, not anonymous. Every transaction to and from an address is public, so anyone who links an address to a person can see that person’s related history. Reusing one address for many payments makes such linking easier.
Bitcoin wallets therefore generate a new address for each incoming payment, while account-based chains such as Ethereum typically use one address per account, which offers less privacy by default. Users who need separation often keep distinct accounts for different purposes.
Blockchain analytics firms and exchanges cluster addresses using heuristics such as common input ownership, in which several addresses spent together in one transaction are assumed to belong to the same wallet. Generating fresh addresses limits but does not eliminate this linking, and merging coins from different sources in a single transaction can undo much of the privacy that fresh addresses provide.
In everyday language
A wallet address is like a mailbox with a glass front. Anyone can see it and drop money into it, and anyone can look at what went in and out, but only the person with the key can open it and take money out.
You can safely give your address to people who want to pay you. What you must never share is the private key or seed phrase, because those are the actual key to the mailbox.
Seen in the real world
A freelance designer agrees to be paid in a stablecoin by a client abroad. She opens her hardware wallet’s companion app, selects the correct network and generates a receiving address beginning with 0x, then confirms the same address on the device screen before sending it to the client.
The client first sends a small test amount, which appears in her wallet within minutes. After she confirms it, the client sends the full invoice. Months later, a stranger sends her a tiny transfer from an address that shares its first and last characters with the client’s. Because she always copies addresses from her own records rather than from transaction history, the poisoning attempt fails and no funds are misdirected.