The price of that independence is not limited to the store receipt. A node consumes electricity all year round, occupies a permanent connection and demands updates before every fork, so the real bill mixes hardware, power, bandwidth and your time. The figures depend on each country's market and on your rate, so the arithmetic is best done with your own prices in front of you.
Full node, archive or validator: choose what you want to be
Before buying anything, decide what role you want to play: following the chain and verifying on your own, or taking the step of signing blocks. The choice changes the budget, the power consumption and the nights on watch.
A full node stores Ethereum's recent state and follows the tip of the chain block by block, without proposing blocks or signing anything. It is the piece that lets you check balances, send transactions and verify receipts against your own copy, and the one that wallets touting that they do not leak your address to a third-party server use internally. An archive node, by contrast, keeps the entire historical state, and that bill is paid in disk.
The official node guide gives the figures. With snapshot synchronization, a Geth or Nethermind node is around 500 GB and a Besu one exceeds 800 GB. In archive mode that same machine goes past 12 TB, while Erigon and Reth require 2.5 TB and 2.2 TB because they do not offer that snapshot. Add about 200 GB of consensus data.
A validator is a full node with an extra responsibility: it signs attestations and, when its turn comes, proposes blocks. That is where the math changes, because the minimum deposit is 32 ETH and the specification raises memory to 64 GB. If your goal is to verify your own operations and not to set up a validation business, a full node is more than enough.
| Type |
What it does |
Reference hardware |
For whom |
| Full node |
Follows the tip, verifies and serves RPC |
4 TB NVMe, 32 GB, 4c/8t, 50/15 Mbps |
Verifying without validating |
| Archive node |
Stores the entire historical state |
From 2.2 to 12 TB depending on client |
Explorers and analysts |
| Attester |
Signs attestations and proposes blocks |
4 TB NVMe, 64 GB, 8c/16t, 50/25 Mbps |
Solo staking |
| Local builder |
Assembles blocks on your machine |
Like the attester, with 100/50 Mbps |
Those who do not use relays |
The requirements that really bite
The disk is the only component that can ruin the project, and EIP-7870 treats it in detail: it calls for M.2 NVMe, not a SATA SSD, and distrusts any drive that does not reach these marks.
- Sequential read and write of at least 2,000 MB/s, the threshold set by the proposal.
- 50,000 IOPS of 4K random read and 15,000 of write, the figure that separates a consumer drive from a working one.
- No DRAM-less drives or QLC cells: the node writes nonstop.
Endurance is measured in TBW, the terabytes the manufacturer guarantees can be written before the cells wear out, and checking that figure before buying is more useful than looking at the price per gigabyte. On capacity, the proposal admits that in January 2025 a 2 TB drive still worked, though the chain's growth turns 4 TB into the bet on the future; the ethereum.org guide warns that 2 TB will probably fall short around 2027.
On memory, 32 GB is the comfortable floor and 64 GB the margin the specification reserves for those who validate, because some client combinations have failed with 16 GB and tests with zk-STARK point to higher consumption.
The processor matters less than people think, but it is not irrelevant: the reference for a full node is 4 cores and 8 threads with about 1,000 PassMark points single-threaded and 3,000 multi-threaded, figures any recent machine meets. The network is the other limit, with 50 Mbps down and 15 up. A connection without a data cap is advisable, because initial synchronization consumes real traffic.
The client pair and why your choice matters
Since the merge of September 15, 2022, an Ethereum node is two programs: an execution client and a consensus client, which talk to each other through the Engine API with a shared secret and should run on the same machine. The execution client processes transactions and maintains the state; the consensus client follows blocks and finality, and also signs your attestations if you decide to validate. Installing one and forgetting the other is the most common mistake of those arriving from old tutorials.
Each layer has its own catalog, and choosing out of habit is not advisable. All are free software, and several publish repositories or Docker images in addition to the binary, which simplifies updates without forcing you to compile.
- Execution: Besu, Erigon, Geth, Nethermind and Reth.
- Consensus: Lighthouse, Lodestar, Nimbus, Prysm and Teku.
Measuring each one's share is harder than it seems. The client diversity registry publishes daily estimates and sets the goal that no client exceeds 33%, with 66% as the danger threshold: with two-thirds of validators, a bug in that implementation could finalize its own fork and cost the deposit of anyone inside. In the October 25, 2026 query the sources do not agree: Miga Labs attributes nearly half of consensus nodes to Lighthouse and Rated.Network places Teku above 53%.
Finality, which depends on two-thirds of validators signing, is the underlying reason. At Observatorio we have followed the proposal to cut finality time to four minutes, and that clock also rests on the infrastructure you are setting up.
How long does synchronization take?
Ethereum does not publish a guaranteed time, and anyone giving you an exact figure is describing their machine and their connection. The official guide leaves two certainties: the disk is the bottleneck and performance improves with better hardware, because the initial startup is input/output intensive. The synchronization mode and the client chosen change the space needed and, along the way, the hours it takes to have it operational.
For the consensus layer there is a shortcut that saves much of the wait: checkpoint sync, which starts the client from a recent checkpoint instead of replaying the entire history from the genesis block, in exchange for trusting whoever publishes that checkpoint. The ethereum.org guide cites it when explaining startup, and clients have it among their options.
When synchronization gets stuck, the order of checks is always the same. See whether the client has connected peers, confirm that the router lets through the listening port 30303 and the discovery port, and monitor disk usage with the system tools. The same guide warns that a forced shutdown can damage the database and force you to resynchronize from scratch, so close with the client and not with the switch.
The cost bill, factor by factor
There is no single price for running a node, and anyone publishing it in euros or dollars will be selling their local market as if it were yours. What you can do is separate the addends and calculate with your numbers: one-time hardware, electricity for 8,760 hours a year, a permanent connection and maintenance time.
- The disk is the item that moves the most: 4 TB of NVMe with DRAM and TLC cells costs considerably more than a laptop SSD, and it is what you should not cut.
- The memory, 32 GB, is bought once and is usually the cheapest part of the setup.
- Electricity comes from multiplying the watts measured at the outlet by 8,760 hours and by the kWh price on your bill.
- Time is the expense nobody records: updates before every fork, disk monitoring and the occasional night of resynchronization.
The levers to lower the bill are few and honest. Reusing a desktop machine that is already on eliminates the hardware purchase and spreads the power across two uses. Sizing the disk to real growth, with 2 TB if the budget is tight, saves the most expensive item even if it forces you to migrate sooner than planned. Renting a cloud server solves maintenance and brings back the dependency the node removed.
Staking at home or delegated: the risk is not the same
Having a node and validating are two different decisions, and confusing them is the fastest way to lose money. A validator needs 32 ETH in deposit, its own keys and a node available almost all the time; the hardware reference rises to 64 GB of memory and 8 cores with 16 threads, and upload bandwidth goes from 15 to 25 Mbps. It is the same machine, with more margin and less right to fail.
The risks are not those of a node that only reads, either. A misconfigured validator can suffer slashing, a penalty that burns part of the deposit and expels the key from the network, and prolonged outages are paid for in lost rewards. Setting up the keys on two machines at once, a classic mistake of those copying a configuration, is the fast track to that burn.
Performance cannot be promised in advance: it depends on how much is staked in total on the network and on the tips market, variables you do not control. What is in your hands is the configuration, and a slip is paid for dearly.
Those who do not want that burden have delegated staking, which hands the ETH to a pool or a service and receives a fee in exchange for trusting its operation. It is more convenient and shifts the technical risk to a third party, exactly the opposite of what your own node provides; on top of that, layers such as restaking have been built, about which we have already reported what remains of EigenLayer after the hype. If the reason for running the node was not depending on anyone, delegating undoes half the work.
The node is expensive sovereignty, and its value lies in what depends on no one
Running an Ethereum node in 2026 costs mostly time and a disk that is paid for once. The electricity item is measured, the network one is negotiated with the operator and the hardware one can be reused, but none of that changes the nature of the invention: a machine that keeps its own copy of the chain and decides whether a transaction is valid.
The cheap version of that sovereignty consists of asking a third-party RPC and trusting its answer. The expensive one is the one you have just read, with 4 TB that fill up, updates that cannot be skipped and a power bill that does not go away. Choosing between the two is not a technical question, but a matter of what you want to depend on you when the service of the day changes its criteria, raises its price or shuts down.