What Is an Ethereum Address? How It's Generated Explained

An Ethereum address is a 42-character string, starting with "0x," that identifies an account on the network — the destination for a transaction, the owner of a token balance, or the location of a deployed smart contract. It's derived mathematically from a private key through a fixed sequence of cryptographic steps, meaning an address can always be regenerated from its key but never reversed back into one.

From private key to public key

The process starts with a private key: a randomly generated 256-bit number, ultimately derived from a /glossary/seed-phrase through a standardized derivation path. From this private key, elliptic curve cryptography (specifically the secp256k1 curve, the same one Bitcoin uses) generates a corresponding public key. This is a one-way relationship: computing the public key from the private key is straightforward, but working backward from the public key to recover the private key is computationally infeasible with current technology.

From public key to address

The Ethereum address itself is not the public key directly — it's derived from it. The public key is run through the Keccak-256 hash function, and the address is the last 20 bytes of that hash's output, prefixed with "0x." Hashing serves two purposes: it shortens the address to a fixed, manageable length, and it adds an extra layer between the address and the public key, since a hash function's output can't be reversed to recover the original input.

Why this design matters for security

Because an address reveals nothing about the private key that controls it, simply knowing someone's Ethereum address gives you no path to compromising their funds — you can only send them assets or read their public on-chain activity. The private key, never the address, is what must stay secret, which is why wallet security guides like /blog/defi-wallet-security focus entirely on protecting the key and seed phrase rather than the address.

Checksum formatting (mixed-case addresses)

Ethereum addresses are technically case-insensitive at the protocol level — uppercase and lowercase hex characters represent the same address. However, a checksum standard (EIP-55) encodes error-detection information into the capitalization pattern of the letters in an address. Wallets and explorers use this mixed-case formatting to catch typos: if you manually alter even one character in a checksummed address, most wallet software will flag it as invalid rather than silently sending funds to a mistyped, potentially unowned address.

Address format	Example pattern	What it signals
All lowercase	0xabc123...	Valid but no built-in typo protection
Mixed-case (checksummed)	0xAbC123...	Same address, with error-detection capitalization

This is why copying and pasting an address exactly, rather than retyping it, is good practice — and why many wallets refuse to proceed if a manually entered address fails checksum validation.

Addresses for contracts versus wallets

The same address format is used both for regular accounts controlled by a private key (externally-owned accounts) and for deployed /glossary/smart-contract accounts, though contract addresses are generated differently — typically derived from the deploying account's address and a nonce (see /blog/what-is-a-nonce-ethereum), rather than from a private key at all, since contracts have no private key and cannot initiate transactions on their own.

Multiple addresses from one seed phrase

A single /glossary/seed-phrase doesn't just generate one address — it can deterministically derive an entire tree of private keys, and therefore an entire tree of addresses, following a standardized derivation path. This is why a wallet can display multiple different "accounts" all recoverable from the same backed-up seed phrase, and why restoring a wallet from a seed phrase on a new device can regenerate not just your original address but every address you'd previously created from that same seed, without needing to separately back up each one.

Why address reuse is discouraged for privacy

Although using a fresh address for every transaction is optional on Ethereum (unlike some privacy-focused designs elsewhere), reusing the same address repeatedly makes it straightforward for anyone to link all of that address's activity together on a public block explorer, as covered in /blog/how-to-read-etherscan-transactions. Because every Ethereum transaction is permanently public, an address used consistently across many interactions can reveal a surprisingly detailed picture of someone's holdings and behavior over time, which is worth weighing for anyone concerned about on-chain privacy alongside standard security practices.

One address, many networks

Because most EVM-compatible /chains use the same underlying cryptography, the same Ethereum address format — and often the exact same address — works across Ethereum mainnet and many other compatible networks. This is convenient, but it also means sending funds to the correct address on the wrong network can result in permanently inaccessible funds if that network isn't supported by your wallet, a common and preventable mistake covered in general wallet security guidance.

Bottom line

An Ethereum address is the end product of a one-way cryptographic chain: a private key generates a public key, which is hashed down into a 20-byte address, then formatted with a checksum to catch typos. Understanding this derivation clarifies why an address is safe to share publicly while a private key or seed phrase never is.