If you need a public Ethereum testnet, use Sepolia. If you are testing validators, staking, or a protocol upgrade, use Hoodi. That is the short answer, and it is also the official one — ethereum.org says "Sepolia is the recommended default testnet for application development," and sends stakers to Hoodi.
The longer answer is that the question has two halves, and the second half is in worse shape than the first. Picking a network is easy. Getting test ETH onto it is not, and the reason is worth understanding before you plan a demo around it.
So I measured the whole path on 15 September 2026: every public RPC endpoint a primary source lists for each Ethereum test network, every faucet ethereum.org links for Sepolia, what one drip actually pays for at the live gas price, and what happens to test ETH that lands on the addresses every tutorial uses.
Three results changed how I would answer the question.
- Of the seven Sepolia RPC endpoints listed by primary sources, two answered. Five of those seven come from the network's own configuration repository, and all five are dead.
- Of the nine Sepolia faucets ethereum.org links, exactly one states that a brand-new address with no mainnet balance can claim. Three require you to already hold ETH on Ethereum mainnet.
- Most of the time you need none of it. A local Anvil fork of Sepolia deployed an ERC-20, deployed an application contract, and exercised both in 1.5 to 2.8 seconds, with 10,000 pre-funded test ETH and no faucet in the loop.
The short answer in a table
| Network | Chain ID | What it is for | Measured on 15 September 2026 |
|---|---|---|---|
| Sepolia | 11155111 | Contracts and applications. The default. | 2 of 7 documented endpoints answered, 12.24s blocks |
| Hoodi | 560048 | Validators, staking, protocol upgrades | 2 of 2 endpoints answered, 13.44s blocks |
| Ephemery | 39438163 today | Throwaway work; resets every 28 days | 1 of 4 endpoints answered, chain ID changes 24 September |
| Platåberget | 7091047534 | Early Glamsterdam testing | 1 of 1 endpoint answered, 16.38s blocks |
| Holesky | 17000 | Nothing. Deprecated September 2025. | 0 of 2 endpoints answered |
What I measured, and how
Everything below comes from a read-only harness in this repository under examples/articles/which-ethereum-testnet-should-i-use-and-where-can-i-get-test-eth. It sends eth_* reads to public endpoints, loads faucet pages in a real browser without submitting anything, and does all of its transaction work inside a local Anvil fork. No faucet was asked for funds while researching this, no form was submitted, and nothing was broadcast to a public network.
The tools were Foundry 1.5.1-stable (anvil, cast, forge), Node.js v22.17.0, viem 2.56.3, Playwright 1.59.1 driving the installed Google Chrome, and Solidity 0.8.36 with the optimizer at 200 runs, on an Apple M3 Pro. Raw JSON for every figure quoted here is in results/.
Two measurement choices are worth stating up front. Every endpoint gets three attempts before it counts as unreachable, because one DNS or TLS hiccup is not evidence about a network. And gas figures come from a local fork rather than from public transactions, which makes them deterministic: the same seven operations produced byte-identical gas in all four runs today.
Sepolia is the default, and most of its documented endpoints are gone
Sepolia is the right answer for application work for a reason that has nothing to do with speed. Its validator set is permissioned — ethereum.org's exact words are "The Sepolia network uses a permissioned validator set controlled by client & testing teams" — so the chain keeps producing blocks whether or not hobbyist validators find it interesting, and its state stays small enough to sync quickly.
What has not held up is the list of places you can talk to it.
The two Sepolia endpoints that answered are publicnode's and ethPandaOps'. Neither is listed in eth-clients/sepolia, the repository that holds the network's configuration. Every one of the five endpoints that repository does list failed: two returned HTTP 404 and three did not resolve at all.
This is not a Sepolia problem so much as a documentation-decay problem, and it repeats. ephemery.dev lists three RPC endpoints; all three failed, and the only Ephemery endpoint that answered was the JSON-RPC proxy exposed by the Blockscout explorer, which the site lists as an explorer rather than as an RPC. Holesky's two documented endpoints are both gone, which is the correct outcome for a network the Ethereum Foundation shut down but a bad outcome for anyone following an old tutorial.
Client libraries lag the same way. viem 2.56.3 ships 731 chain definitions, 334 of them flagged as testnets. It still exports goerli, for a network deprecated in December 2023, and holesky. I checked the endpoint each definition defaults to, because that is what createPublicClient({ chain, transport: http() }) actually dials:
sepolia,hoodi,baseSepolia,optimismSepoliaandarbitrumSepoliaall answered with the chain ID they declare.holesky's default endpoint returned HTTP 404.goerli's default endpoint returnedRPC -32001: Invalid chain.
Etherscan's V2 chainlist — the one API key that forge verify-contract and Hardhat's verify plugin talk to — currently covers 62 chains and includes Sepolia and Hoodi but neither Goerli nor Holesky. If contract verification is part of the reason you want a public testnet, that list, not a chain definition in a library, is the one to check first.
One more endpoint-level caveat, because it bit me while reading the raw data. The two Sepolia endpoints agreed exactly on the head block and disagreed sharply about finalized: publicnode reported a finalized block 4,858 blocks behind the head, about 16.7 hours old, while ethPandaOps reported 71 blocks behind, about 15 minutes old, in the same probe, on the same head. The same publicnode behaviour showed up on mainnet in the same run, where its finalized block was 4,973 behind against drpc's 69. If anything you build waits for finality on a testnet, do not take a single public endpoint's word for where finality is.
The other networks answer different questions
Hoodi is where validators go. It has an open validator set, which is exactly the property Sepolia gives up, and ethereum.org is explicit: "Stakers wanting to test protocol upgrades before they are deployed to mainnet should therefore use Hoodi." Both of its documented endpoints answered, at 13.44 second average blocks over the last 200. If you are writing contracts, this buys you nothing over Sepolia and costs you a larger chain to sync.
Ephemery is the interesting one and the most misunderstood. It resets completely every 28 days, and EIP-6916, which is Final, specifies the reset: each iteration derives its chain ID as genesis_0.chainId + i. The live network today is iteration 163 with chain ID 39438163. The repository's values.env already carries the next one: iteration 164, chain ID 39438164, genesis 24 September 2026 at 19:00 UTC. Both numbers check out against the rule — 39438163 − 163 and 39438164 − 164 both give the same base — which means the chain you connect to today stops existing in nine days, along with every contract on it. For CI that wants a genuinely fresh chain, or for load tests you would feel guilty running on Sepolia, that is a feature. For anything a teammate needs to open next month, it is a trap.
Platåberget is not a general-purpose testnet at all. It is the Glamsterdam early testing ground, "open to public participation" and intended to "run for a few months." Its single documented endpoint answered, reporting chain ID 7091047534 and 16.38 second average blocks. The announcement is specific about who should care: anything that assumes a hard-capped maximum gas limit will break under the Glamsterdam gas repricing. That is a tooling-compatibility question, not a "where do I deploy my ERC-20" question.
Holesky is finished, and both its documented endpoints confirm it.
There is one piece of forward-looking news worth knowing while you are choosing. In May 2026 the Ethereum Foundation's Parithosh Jayanthi opened a proposal on Ethereum Magicians to replace Sepolia, on the grounds that its state will become expensive to run around mid-2027: a new network reaching the latest fork by Q1 2027, with Sepolia deprecated after that launch and fully sunset in Q2/Q3 2027, "giving everyone about half a year to deploy and update to the new network." That is a proposal open for pushback, not a scheduled shutdown, and the thread's last reply is from August 2026. It does not change what you should use today. It does mean that a contract you deploy to Sepolia is not a permanent address.
Where to get test ETH, and what each faucet actually asks for
Here is the part that has quietly changed. I loaded all nine Sepolia faucets ethereum.org links, in a real browser, and read what each one says about its own eligibility rules. Nothing was submitted and nothing was claimed, so every row below is the operator's own description rather than an outcome I observed.
Three of the nine require a mainnet balance. Chainstack's page states it plainly: "The requesting address must have a minimum balance of 0.08 ETH on the Ethereum mainnet," plus "The address should have a history of holding ETH on the mainnet; it should not have been recently empty." Alchemy's page says "No account required" and, further down, "You need at least 0.001 ETH on Ethereum Mainnet for EVM-based testnets." Google Cloud's FAQ answers the same 0.001 ETH error.
One requires history that closed almost four years ago. Grabteeth: "Addresses that have deployed one or more contracts on Mainnet / Goerli / Sepolia before November 15, 2022 are eligible for a one time claim."
One requires you to mine. The pk910 proof-of-work faucets — which also cover Hoodi, Ephemery and Platåberget — state their reasoning directly: "this faucet requires some mining work to be done in exchange for free testnet funds."
One has no faucet page left. The URL ethereum.org lists for Infura redirects to the Infura home page.
Exactly one of the nine says a new wallet can just claim. QuickNode: "The base drip is free and requires no Quicknode account, no post on X and no minimum mainnet balance, so a brand new wallet can claim," with a 12-hour cooldown per address per network.
The pattern is the one ethereum.org itself warns about a few paragraphs earlier: "ETH on testnets is supposed to have no real value; however, there have been markets created for certain types of testnet ETH that have become scarce or hard to obtain." The anti-abuse answer the industry converged on is a proof of stake in the real world — mainnet ETH, an account, or CPU time. Which means the standard advice, "just grab some from a faucet," now assumes you already have ETH.
It is also worth knowing which links are simply broken before you spend an afternoon on them. Beyond ethereum.org's nine, eth-clients/sepolia lists four more; of those, RockX sat behind a Cloudflare challenge, LearnWeb3 returned 503 "Service Suspended", and Unitap returned 500. Ephemery's Bordel faucet, which two days earlier advertised "Receive 1024 ETH per request", returned 502 on all three attempts today. Across all 22 faucet URLs I loaded, 18 responded with a 2xx.
What one drip actually buys
"0.1 ETH every 24 hours" means nothing until you know what a deployment costs. So I measured the cost side rather than estimating it.
The workload is what I would call a day-one sequence: deploy a plain ERC-20, deploy a small application contract, transfer to a cold address, approve a spender, and write one 32-byte message into the app contract. Five transactions, measured on a local fork of Sepolia so the numbers are exact and repeatable.
| Operation | Gas |
|---|---|
| Deploy ERC-20 | 397,558 |
| Deploy application contract | 356,938 |
| ERC-20 transfer to a cold address | 51,393 |
| ERC-20 approve | 46,163 |
| First message written | 92,054 |
| Total | 944,106 |
At the eth_gasPrice Sepolia reported during the probe, 1.008597 gwei, that whole sequence costs 0.00095 ETH. So:
- Alchemy's 0.1 ETH covers about 105 complete day-one sequences, or 249 ERC-20 deployments.
- Chainstack's top-up to 0.5 ETH covers about 525 sequences.
- On OP Sepolia, where gas was 0.001 gwei, the Superchain console's 0.01 ETH covers about 10,589 of them.
One drip is not scarce. One drip is about a hundred full deploy-and-exercise cycles, and the daily cooldowns most faucets apply are far more generous than a normal deploy-test-iterate loop needs. If you are running out of test ETH, the likely cause is automation hammering a public chain rather than a person building an application.
The gas price is the part that surprised me. In the same run, Sepolia's base fee was 1.007597 gwei while Ethereum mainnet's was 0.050166 gwei — the testnet was charging about twenty times mainnet's rate at that moment. That is one reading of two moving numbers and it will look different tomorrow, but it is a useful corrective to the idea that testnet gas is free-floating and irrelevant. It is priced by the same mechanism, and on a testnet nobody is arbitraging it.
Do not send it to the addresses in the tutorial
This is the finding I did not expect, and it is the easiest way to lose a drip you waited 24 hours for.
Anvil prints ten development accounts derived from the published mnemonic test test test test test test test test test test test junk. It is not a Foundry quirk: the same string is EDR_NETWORK_MNEMONIC in Hardhat 3.16.0, with the same 10,000 ETH default balance. Anvil's banner is where most people first meet them:
Available Accounts
==================
(0) 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 (10000.000000000000000000 ETH)
(1) 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 (10000.000000000000000000 ETH)
Their private keys are published in the tool's own output. That is fine locally and catastrophic on a public chain, and the consequence today is sharper than "someone might take it." Here is account 0 on public Sepolia:
$ cast code 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url https://ethereum-sepolia-rpc.publicnode.com
0xef0100ff0bdcd00357eacf612ddc449aa590b90215a013
$ cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url https://ethereum-sepolia-rpc.publicnode.com
2194191530677
$ cast nonce 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url https://ethereum-sepolia-rpc.publicnode.com
47878
An externally owned account is not supposed to have code. The 0xef0100 prefix is the EIP-7702 delegation marker: the remaining 20 bytes are the address whose code runs in this account's context. All ten default addresses carry one. Accounts 0 and 1 delegate to a 333-byte contract; accounts 2 through 9 delegate to a 7,573-byte one. The account has sent 47,878 transactions on Sepolia and holds 0.0000022 ETH.
Reading the delegates' bytecode would be guesswork, so I ran the transfer instead. On a fork of Sepolia, from a freshly generated funded key, I sent 0.01 ETH to each of the ten addresses in turn, traced each transaction, and reverted the chain between them so no sweep could pay for the next:
- 10 of 10 transfers were forwarded out of the recipient inside the same transaction. None of the ten kept anything.
- The ether went to two collector addresses, which on public Sepolia currently hold 2,002.67 and 110.71 ETH.
- The transfers cost 31,656 to 31,867 gas instead of the 21,000 a plain transfer to a fresh address costs. You pay the sweeper's gas.
There is no window here. It is not a bot racing you to the next block; the delegated code runs in the same transaction that delivers the funds. Test ETH sent to a default development address is gone on arrival.
So: generate a throwaway key for public testnet work, keep it out of the repository, and never reuse a mainnet account. That last one is also ethereum.org's advice, for the same underlying reason.
You probably do not need a faucet at all
Here is the measurement that reframes the whole question.
The faucet exists to fund transactions on a public chain. Most of the work that sends developers to a faucet does not need a public chain — it needs a chain with realistic state. Anvil gives you that in one command, with ten accounts holding 10,000 test ETH each, which Foundry's own documentation states as the default. It is also the fastest loop you have: when I benchmarked Foundry against Hardhat 3, both frameworks ran 200 Solidity unit tests in roughly a third of a second.
Forking makes it realistic:
$ anvil --fork-url https://ethereum-sepolia-rpc.publicnode.com --port 8573 --silent
$ cast chain-id --rpc-url http://127.0.0.1:8573
11155111
$ cast call 0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14 "symbol()(string)" --rpc-url http://127.0.0.1:8573
"WETH"
$ cast balance 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 --rpc-url http://127.0.0.1:8573
10000000000000000000000
The chain reports Sepolia's chain ID, Sepolia's deployed WETH answers a call with 3,124 bytes of real code behind it, and the development account holds 10,000 ETH that no faucet issued and no sweeper can take.
I timed the full cold sequence — forge build, start the fork, deploy both contracts, run the five operations, read the state back — three times in a row. It took 1,466 ms, 2,522 ms and 2,844 ms, with the fork itself ready in 506 to 1,119 ms of that. The gas figures were identical across all runs, which is the other reason to work this way: a local fork gives you a repeatable measurement where a public testnet gives you one sample plus whatever else was in the block.
That is the honest hierarchy.
The faucet moment is real, and it arrives exactly when something outside your machine has to reach the chain: a frontend you want someone else to click, a contract you want verified on a public explorer, a webhook from an indexer, a teammate reviewing a deployment. Everything before that point is faster, more repeatable and completely ungated on a local fork.
What this does not prove
This is one machine, one afternoon, and one sample per endpoint.
Reachability is a snapshot. An endpoint that returned a 404 today may be fine next week, and three attempts is enough to filter transient failures but not enough to call something permanently dead. The consistency across two runs two days apart makes me confident about Holesky and about the eth-clients Sepolia list; I would not generalize from one bad response on a single URL.
The faucet results are what each operator says, not what each operator does. I did not request funds from any of them, so I cannot tell you whether QuickNode's "a brand new wallet can claim" holds in practice, or whether a faucet with no stated rule silently applies one. A page that states no eligibility rule is recorded here as stating no rule — not as being open.
The cost arithmetic multiplies gas measured on a fork by a gas price read at one moment. The gas is solid and repeats exactly. The prices move, and the twenty-to-one Sepolia-to-mainnet ratio is a single reading, not a trend.
The sweep finding is specific to Sepolia and to the ten default addresses, measured through debug_traceTransaction on a fork. I did not check other testnets, and I did not attempt to work out who operates the collectors or what their code does beyond following the value.
Finally, timings are from an M3 Pro with a warm Foundry install and a fast connection; the fork startup time in particular depends on how quickly your upstream RPC answers.
The decision
For contract and application work, use Sepolia — but reach for it third, not first. Local Anvil for development, anvil --fork-url against Sepolia when you need real deployed state, and a public testnet only when something outside your machine must reach it.
When you do need test ETH, expect to be asked for something. Three of the nine faucets ethereum.org lists want mainnet ETH, one wants a 2022 deployment history, one wants your CPU, and one no longer exists. QuickNode's is the one that currently states a new wallet can claim, and pk910's proof-of-work faucets are the reliable fallback across Sepolia, Hoodi, Ephemery and Platåberget if you would rather spend CPU than hold mainnet ETH. One claim is worth about a hundred full deploy-and-exercise cycles, so this is a question you should have to answer once.
Use Hoodi only for validator and staking work, Ephemery only for things that can vanish in under 28 days, and Platåberget only to find out whether Glamsterdam's gas repricing breaks your tooling. Do not use Holesky; it is gone.
And whatever you claim, send it to a key you generated. The ten addresses printed in every tutorial are not merely public — on Sepolia they are wired to forward anything they receive, in the same transaction, ten times out of ten.