< RETURN_TO_BLOG
What is an Ethereum testnet?
blog // ID_11

What is an Ethereum testnet?

What are testnets? Which ones should you use and what for?

When you’re building on Ethereum, you don’t want your first experiment to cost real money or accidentally lock real funds forever. That’s what testnets are for: Ethereum-like networks where the ETH has no real value, but the rules behave close enough to mainnet that you can safely test deployments and integrations.

If you’re new to this stuff, it helps to first read a general intro to cryptocurrency and how a blockchain works. Also: you’ll need a wallet to interact with any network.

What is a testnet?

A testnet is a separate Ethereum network that follows the Ethereum protocol, but is isolated from mainnet.

That means:

  • Your Ethereum account (private key) can be used on testnets
  • Your balances and transaction history do not carry over
  • Testnet ETH is typically obtained from faucets (free distribution sites)
  • You still pay gas - just with valueless ETH

Ethereum’s own developer docs describe testnets as a production-like environment for testing contracts and protocol upgrades before mainnet deployment (ethereum.org Networks docs).

The only public Ethereum testnets you should care about in 2026

Ethereum rotates testnets over time because testnets accumulate “junk state” and become expensive to run. As of late 2025/2026, Ethereum’s docs list these as the maintained public testnets:

Sepolia (recommended for smart contracts and apps)

Sepolia is the default testnet for dapp + smart contract development. It uses a permissioned validator set run by client/testing teams, which keeps it stable and easy to maintain (ethereum.org: Sepolia).

Typical use cases:

  • deploy and test smart contracts before mainnet
  • test frontends / wallets / integrations
  • staging environment for app releases

Faucets and explorers are linked from Ethereum’s official networks page (ethereum.org Networks docs).

Hoodi (validator + staking + protocol upgrade testing)

Hoodi is the public testnet meant for staking operators, infrastructure providers, and protocol testing. It has an open validator set and larger state, so it’s “more mainnet-like” but heavier to run (ethereum.org: Hoodi). It was introduced during the transition away from Holesky (Ethereum Foundation: “Holesky and Hoodi Testnet Updates”).

If you’re “just deploying contracts”, use Sepolia. If you’re running validators or testing protocol-level changes, use Hoodi.

Ephemery (optional, resets monthly)

Ephemery is a special case: it resets back to genesis every ~28 days, making it useful for quick experiments and fast bootstrapping, not long-running deployments (ethereum.org: Ephemery).

Local testnets (the fastest way to build)

Public testnets are great, but they’re still shared infrastructure. For fast iteration, you usually run a local Ethereum node on your machine.

The modern “default choices” in 2026:

Older tooling like Ganache exists, but Consensys announced the sunset of Truffle and Ganache and recommends migrating to actively maintained tooling (Consensys announcement).

The really cool thing about these local testnets is that they can "instafork" a live network. This means you can point them at even live Ethereum mainnet, and you instantly get a copy of its live state. This lets you experiment on actually live contracts with live money in them as if in production, only locally, safely, and with a wallet full of unlocked infinite money. Tooling such as this made bug-hunting a breeze in Web3!

Decommissioned testnets (quick history, don’t use)

If you see tutorials referencing these, assume they are outdated:

A note about Layer 2 testnets

Most L2s run their own testnets, often anchored to Ethereum testnets.

Examples:

  • Polygon PoS launched Amoy as a Sepolia-anchored testnet as Mumbai (Goerli-anchored) was phased out (Polygon announcement).
  • Base uses Base Sepolia for test deployments (Base docs).

Each chain will have docs about their testnets, so refer to those if you need them. Even so, our recommendation is to just use Foundry's Anvil on any production chain - even L2s.

Practical “how do I use this?” checklist

  1. Create a wallet (MetaMask, Rabby, hardware wallet, etc.)
  2. Select Sepolia (for app testing) or Hoodi (for validator/protocol testing) in your wallet. You can add them to your wallet's settings via chainlist.org.
  3. Get test ETH from a faucet (Ethereum’s docs list multiple options for both networks: Networks page)
  4. Deploy your contract using your toolchain (Foundry/Hardhat/etc.)
  5. Verify transactions on an explorer (Etherscan/Otterscan/Blockscout links are on the same Ethereum Networks page)

That’s it. If a tutorial tells you to use Ropsten/Rinkeby/Goerli, it’s living in a museum.