Tool AT-W41REV. 2026-A
Node planner: your own node or an RPC provider for Ethereum and L2?
For a few hundred thousand requests a day, an RPC provider is usually enough. Your own node pays off under high load, if your users’ addresses should not end up with third parties, or if you query old state. An Ethereum full node needs 429 GB to 2.2 TB of disk and 32 GB of RAM depending on client and history, an archive 2 TB to 14 TB. The planner works this out for your load, with the date and source next to every figure.
- free
- no sign-up
- runs in your browser
01 / PLANNER
Enter network, purpose and load, then read off the recommendation and hardware
Planner · node or provider, hardware per client
The planner works from the client documentation (date and source are shown next to every figure) and from labelled estimates. It is no substitute for a load test with your real queries. It is not investment advice, and it never asks for keys or seed phrases.
Runs in your browser. Nothing is sent or stored.
02 / NODE TYPES
Which node answers which query?
The first question is not “which client”, but: how far back does your application need to look? A full node checks every block itself and holds the current state. It keeps old states only briefly, in Geth the last 90,000 blocks (about 12.5 days), in Besu 512 blocks by default. Blocks, receipts and logs, on the other hand, it can keep in full, from the Merge onwards, or for just a few months. That makes the biggest difference to storage, more than the choice of client.
| Node type | keeps | Drive | enough for |
|---|---|---|---|
| Full node, rolling history | current state, blocks and receipts of the last 147 days or so | 429 GB bis 634 GB | balances, eth_call, sending, events of the last few months |
| Full node, history from the Merge | current state, blocks and receipts since 15.09.2022 | 1.2 TB to 1.4 TB | events and receipts since September 2022 |
| Full node, full history | current state, all blocks and receipts since 2015 | 1.8 TB to 2.2 TB | events and receipts since 2015, for contracts from before the Merge, for example |
| Archive node | plus every old state since the first block | 2 TB bis 14 TB | state at any old block, trace_* and debug_trace* on old blocks |
Rolling: about 147 days (33,024 epochs); Geth does not support this yet. Measurements from Eth Docker (September 2026), archives from the client documentation; as of 14 November 2026.
Why the state matters so much: the biggest effort in setting up a full node is synchronising the state of all accounts, although over 95 per cent of them are dormant Kim et al. 2021. It keeps growing even if the node drops old blocks. That is why many applications rely on other people’s nodes instead of running their own. Whether your application needs a blockchain at all is something the blockchain suitability check clarifies beforehand.
03 / CLIENTS
Storage, RAM and sync per client
An Ethereum node consists of two programs: the execution client, which processes transactions and holds the state, and the consensus client (beacon node), which follows the chain. The table lists the requirements of the execution clients; disk capacity depends on the node type, and RAM on the version. ethereum.org gives as minimum 2+ cores, 16 GB (32 GB for stability), 4 TB NVMe and 25+ Mbit/s; recommended under EIP-7870 are 4 cores / 8 threads, 32 GB and 4 TB NVMe (no DRAM-less, no QLC model).
| Client | full | from Merge | rolling | archive | RAM measured / docs | Sync |
|---|---|---|---|---|---|---|
| Geth 1.17.5 | over 1.7 TiB | about 1.3 TiB | not supported | about 2 TB (path archive, state history only) | about 8 GiB Docs: at least 16 GB | about 3 hours (snap sync, 1.17.2, April 2026) |
| Nethermind 2.0.0 | about 1.6 TiB | about 1.2 TiB | about 450 GiB | at least 14 TB (as of July 2023) | about 10 GiB (13 GiB during sync) Docs: 16 GB, 4 cores; disk with at least 10,000 IOPS | about 2 hours (1.36.0, February 2026), ready for attestations after about 1 hour |
| Besu 26.8.1 | over 1.7 TiB | about 1.1 TiB | about 430 GiB | about 12 TB (Forest, undated) | about 10 GiB Docs: JVM at least 8 GB; reference: 8 vCPU and 30 GiB | about 13 hours (rolling, 26.1.0, February 2026) |
| Erigon 3.6.0 | about 1.6 TiB | about 1.1 TiB | about 590 GiB | 2.25 TB used, 4 TB recommended (17.09.2026) | about 18 GiB (uses free RAM, releases it when needed) Docs: 16 GB required, 32 GB recommended | about 12 hours (rolling, 3.3.8, February 2026); Erigon docs: full mode about 5 h 40 min at 400 Mbit/s |
| Reth 2.5.2 | about 2 TiB (with receipts) | about 1.2 TiB | about 400 GiB | at least 2.8 TB (as of 23.06.2025) | about 14 GiB Docs: 8 GB+ (full), 16 GB+ (archive), 16 GB recommended in general | about 2 hours with a database snapshot (2.0.0, April 2026); without a snapshot on an older mini PC about 17 days |
Full, from Merge, rolling, RAM and sync: Eth Docker, Client Resource Usage, measured February to September 2026. Archives: Geth (24.02.2026), Nethermind (July 2023), Besu, Erigon (17.09.2026), Reth (23.06.2025).
- Geth In a full node, Geth keeps the state of the last 90,000 blocks (about 12.5 days) queryable. Rolling history not yet supported. Archive with old trie history for eth_getProof: about 6.5 TB.
- Nethermind The archive figure is from July 2023; Nethermind itself gives it as a lower limit.
- Besu Bonsai (default) reconstructs old state only 512 blocks back; an archive runs with Forest, which according to Besu needs considerably more storage.
- Erigon Its documentation lists its own modes: minimal 524 GB, full (default) 535 GB, archive 2.25 TB, measured on 17.09.2026.
- Reth Reth recommends TLC NVMe rather than QLC; old block files may go on a slower disk (--datadir.static-files).
Fig. 1 · Disk per execution client without beacon node, Eth Docker September 2026; archives from the client documentation, shown at left under the name.
Consensus clients (beacon node)
| Client | measured | Database | RAM | Figure in the docs |
|---|---|---|---|---|
| Lighthouse 8.2.2 | September 2026 | about 15 GiB | about 14 GiB | With execution client: 32 GB RAM (16 GB “quite tight”), four cores, 2 TB SSD, 100/20 Mbit/s |
| Prysm 7.1.3 | April 2026 | about 20 GiB | about 9 GiB | The hardware page of the docs was unavailable on 14.11.2026 |
| Teku 26.4.0 | April 2026 | about 80 GiB | about 10 GiB | Full node with validator: 4 cores at 2.8 GHz, 16 GB RAM, 2 TB SSD, 10 Mbit/s (docs 26.10.1) |
| Nimbus 26.8.0 | September 2026 | about 90 GiB | about 5 GiB | Beacon node: 4 GB RAM, 200 GB; with execution client: 2 TB SSD, 16 GB RAM |
| Lodestar 1.42.0 | April 2026 | about 20 GiB | about 12 GiB | Beacon node: 8 GB RAM, 130 GB SSD (16 GB, 200 GB recommended); with execution client: 4 TB SSD, 32 GB RAM; Node.js from 24.22.1 (docs 1.50.1) |
Measurements: Eth Docker. Docs: Lighthouse Book, Teku 26.10.1, Nimbus Guide. A supernode with all blobs needs about 537 GB more.
The clients differ markedly; even early measurements of the beacon chain showed storage and memory far apart between implementations Cortes-Goicoechea et al. 2021. A later series of measurements of about 30,000 CPU hours concluded that the need is higher than originally stated: execution and consensus client together took 15 to 23 GB of RAM, and during a fresh sync the CPU load rose to three to four times Cortes-Goicoechea et al. 2024. For memory, the planner takes the measured RAM plus 15 GB for the beacon node, adds a 20 per cent buffer and never goes below 32 GB; the buffer is an estimate, not a measured value.
And the disk has to be fast, not just big. Input and output shape the cost of a transaction more than the gas model reflects, and less well-equipped nodes fall behind as a result Yang et al. 2019. Nethermind requires at least 10,000 IOPS, Eth Docker advises TLC SSDs with DRAM, and hard disks are ruled out.
How fast the disk fills up
No client currently gives a figure per month. The planner therefore derives growth from two parts, both calculated openly. According to EIP-8037, state grew in January 2026 at 60 million gas by about 326 MiB a day, which is about 10 GB a month. For blocks and receipts we back-calculated the Eth Docker measurements: the difference between “from Merge” and “rolling” gives on average about 16 GiB a month since the Merge, mostly at half the gas limit. We therefore calculate with double that, about 34 GB.
- Rolling history: about 10 GB a month. Old blocks drop out, only the state grows. A Nethermind node gets by with 1 TB over two years.
- Full history or from the Merge: about 44 GB a month (estimate). Over two years, Geth with full history needs 3 TB including the beacon node, which with a buffer means a 4 TB drive. That matches the 4 TB that EIP-7870 recommends.
- Archive: about 88 GB a month (estimate), Nethermind according to its docs about 60 GB a week. For path archives no docs give a rate; we assume twice that of a full node.
04 / LAYER 2
Arbitrum, OP Mainnet, Base and Polygon: what your own node needs
An L2 node is not a smaller Ethereum node, but often the larger one. Arbitrum One requires at least 64 GB of RAM, Base 32 GB with 64 recommended. Arbitrum, OP Mainnet and Base also need access to Ethereum, as RPC and as beacon API for the blob data; Base requires its own Ethereum access for this, not an endpoint of Base. Polygon PoS requires Ethereum access only from validators.
| Network | Full node | archive | RAM / CPU | Ethereum access |
|---|---|---|---|---|
| Arbitrum One Nitro v3.12.2 | Snapshot about 2.3 TB (HashDB, pruned) or 2.4 TB (PathDB full-path) | Snapshot about 3.7 TB (PathDB archive-path) | 64 GB DDR5 minimum, 128 GB recommended 8 cores (3rd generation) minimum, 16 recommended | Ethereum RPC (execution) and beacon API for blobs; if L1 access was offline for more than 18 days, historical blobs are needed |
| OP Mainnet op-node v1.18.2 + op-reth v2.2.5 | about 700 GB | according to the docs “several terabytes” | not stated not stated | Ethereum RPC (execution) and beacon API for blobs |
| Base base-reth-node (base/base from v1.5.1) | at least 2 TB (Reth docs, 23.06.2025) | at least 4.1 TB (Reth docs, 23.06.2025) | 32 GB minimum, 64 GB recommended (Base); the Reth documentation specifies 128 GB+ at least 8 cores with good single-core performance | own Ethereum access (full-node RPC) and beacon API, not a Base endpoint |
| Polygon PoS Heimdall + Bor (archive: Erigon) | 4 TB minimum, 6 TB recommended | 16 TB (Erigon) | 32 GB minimum, 64 GB recommended 8 cores minimum, 16 recommended | Ethereum RPC needed only for validators |
Sources: Arbitrum, OP Stack, Base, Reth, Polygon, retrieved 14 November 2026. The pages mostly give no date, only the software version.
None of these docs gives growth per month. The planner therefore uses the rule that Base itself states: double the chain size plus 20 per cent. That also fits Arbitrum, where unpacking a snapshot needs about twice the free space. For OP Mainnet, op-geth has been unsupported since 31.05.2026; the recommended client is op-reth.
05 / LOAD
Requests and availability: how the planner calculates
How many requests a node can handle is not stated in any documentation, because it depends heavily on the methods. An eth_blockNumber costs almost nothing, an eth_getLogs over a million blocks a lot. The planner therefore works with load units: one heavy query counts as 20 light ones, and a well-equipped node in our experience carries about 200 light ones a second, of which we plan on 60 per cent. All three figures are estimates from our own practice. After the build, only a load test with your real queries counts.
An example: 2,000,000 requests a day are 23.1 a second on average. With a fivefold peak and 5 per cent heavy queries, that becomes 226 load units, so 2 nodes for the load. With an operations team, the planner recommends your own full node here; for 99.9 per cent one more is added, for a total of 3 nodes.
| Target | Downtime/month | Full node (2 to 13 h) | Archive (14 h to 2 weeks) |
|---|---|---|---|
| 99 % | 7.3 hours | tight, fallback | second node needed |
| 99,5 % | 3.7 hours | tight, fallback | second node needed |
| 99,9 % | 44 minutes | second node needed | second node needed |
| 99,99 % | 4.4 minutes | second node needed | second node needed |
Rebuild: Eth Docker sync times, Erigon and Geth docs. From 99.99%, the planner assumes three nodes at two sites (estimate).
A second access path is no luxury. In a study of nine Ethereum RPC services, all could be deliberately slowed down, and at least 63 per cent of DApps depended on a single service Li et al. 2021. Your own node does not always fail visibly either. Anyone who controls about half of its peer connections can cut it off from the network for hours while it carries on running normally Heo et al. 2023, and in the P2P network as early as 2018 fewer than half of the nodes found contributed to the mainnet at all Kim et al. 2018. So monitor the distance to the chain head and the number of usable peers, not just whether the process is running. How fast your connection really is, the speed test shows; ethereum.org recommends 50 Mbit/s down, 15 Mbit/s up.
06 / CLIENT DIVERSITY
Why the client with the smaller share is often the better choice
Ethereum runs on several independent clients. If one of them has a bug and a share of more than a third, the chain can no longer finalise; from two thirds, according to ethereum.org, a wrongly finalised chain is a risk, and validators on it are penalised. How serious this is was shown by the first “inactivity leak” in May 2023: under this mechanism, attackers can get past the critical one-third threshold Pavloff et al. 2024. The distribution is still skewed, and proposals to reward minority clients verifiably are only at the beginning Ron et al. 2026.
| Client | Share | Assessment |
|---|---|---|
| Geth | 41 % | over a third |
| Nethermind | 38 % | over a third |
| Besu | 16 % | under a third |
| Erigon | 3 % | under a third |
| Reth | 2 % | under a third |
| Client | Share | Assessment |
|---|---|---|
| Lighthouse | 42,7 % | over a third |
| Prysm | 30,9 % | under a third |
| Teku | 13,9 % | under a third |
| Nimbus | 8,7 % | under a third |
| Lodestar | 2,7 % | under a third |
Snapshot on ethereum.org (page dated 23.02.2026): execution according to supermajority.info of 26.10.2025, consensus according to Blockprint; Grandine 1.0%, others 0.1%. Live values: clientdiversity.org, where the sources differ widely on 14.11.2026.
For a node that only reads, the share is less an obligation than a safeguard: if your client follows a wrong chain, your application reads wrong data. Anyone running two nodes should therefore use two different clients. Then test before the load balancer, because four large implementations answered the same RPC calls differently in 48 classes of cases Kim and Hwang 2023, and some bugs show only in a particular state of the chain Zhong et al. 2026. So test with your own contracts, not just with sample calls.
07 / DATA PROTECTION
What an RPC provider learns about your users
Every query gives something away: which address, which contract, and which IP address it comes from. The MetaMask privacy notice (revised 01.10.2026) describes this for Infura as the default RPC as follows: wallet addresses are processed for the wallet’s functions, IP addresses briefly, for routing and security, for example. Other providers address this in their own notices.
- The service itself can link them. From packet sizes and time intervals, a user’s address could be linked to their IP address, with a hit rate of 98.7 per cent on the testnet and 96.6 per cent on the mainnet Wang et al. 2024.
- An observer on the network can too. The times at which a wallet asks for the status of its transaction were enough for over 95 per cent, without any fees of their own and across several chains Wang et al. 2025.
- Your own node keeps it with you. Integrity, availability and privacy together are secured today only by your own full node Luo et al. 2022. If you stay with a provider, you can check its answers against the chain with a light client, which needs hardly any disk Chatzigiannis et al. 2022.
A dedicated node is the middle way: it runs only for you, and what the operator may see and store is set out in the data processing agreement (Auftragsverarbeitungsvertrag). For your customers’ personal data, that is the normal case.
08 / METHOD
How to plan access to the chain
- Count the queries. What does your application ask, how often, and how far back? Your provider’s dashboard or your backend’s log gives the figures.
- Choose the node type. Old state needs an archive, old events only the right history. That saves terabytes.
- Choose the client. Disk and RAM from the table, plus the share: where it fits, one under a third.
- Size the hardware. Local NVMe drive with a buffer for two years, RAM not below 32 GB, a UPS so that a power cut does not force a rebuild.
- Set up a fallback. A second node with a different client or a provider as reserve, depending on the availability target.
- Monitor and test. Distance to the chain head, peers and disk usage with alerts; after every update, run your own queries through once.
Where the planner stops
- Hardware as per the docs. The values apply to the version named and change with every new one; date and source are shown next to every figure.
- Growth and load as estimates. Labelled and with the calculation shown, but no substitute for measurement and a load test.
- No prices. The cost of providers, servers or operations belongs in a quote (Angebot), not in a planner.
How we bring blockchain data into existing applications, with an indexer, data freshness and a fallback, is described under Web3 and blockchain development. We procure servers for your own node through hardware procurement and set them up as described under servers and virtualisation. More tools around Ethereum are in the overview of Web3 tools.
09 / FOR AI ASSISTANTS
Using this tool from an AI assistant
Assistants such as Claude or ChatGPT that speak the Model Context Protocol (MCP) can call this page’s calculation directly instead of rebuilding it. The server is public, needs no sign-in and stores nothing. The answer always includes the link to this page, the date of the data and the limits of the result.
- Endpoint
https://aureum-tech.com/mcp- Tool
werkzeug_node_planer- Transport
- Streamable HTTP, read-only
| Name | Required | Meaning |
|---|---|---|
chain | yes | Network: ethereum = Ethereum Mainnet; arbitrum = Arbitrum One; op = OP Mainnet; base = Base; polygon = Polygon PoS. |
zwecke | yes | What the access is for, at least one: zustand = Read current state (balances, contract data, eth_call on the latest block); senden = Send transactions (submit signed transactions and wait for the receipt); events = Index events (eth_getLogs over many blocks, for a dashboard for example); historie = Query old state (archive) (balance at an old block, trace_* and debug_trace* on old blocks). |
rueckblick | no | How far back blocks, receipts and logs must reach: aktuell = Only the last few days; monate = Up to about four months back; merge = Since the Merge (15.09.2022); genesis = Since the first block (2015). If omitted, aktuell. |
anfragen_pro_tag | yes | JSON-RPC requests per day, all methods together. |
spitzenfaktor | no | Ratio of peak load to average (e.g. 5 = at peak five times as many requests per second). If omitted, 5. |
anteil_schwer_prozent | no | Share of heavy queries in per cent (eth_getLogs over many blocks, trace_*, debug_trace*). If omitted, 5. |
verfuegbarkeit_prozent | no | Availability target in per cent, e.g. 99, 99.5, 99.9 or 99.99. If omitted, 99.9. |
datenschutz_wichtig | no | true if queried addresses and users’ IP addresses should not end up with a third-party provider. If omitted, false. |
eigenes_betriebsteam | no | true if your own team can update, monitor and rebuild nodes. If omitted, false. |
planungs_monate | no | Period the disk should last for, in months. If omitted, 24. |
Questions where an assistant should call it
- “Do I need my own node for my dashboard with 2 million Ethereum queries a day, or is an RPC provider enough?”
- “How much storage does an Ethereum archive node with Erigon or Reth need, and how fast does it grow?”
- “What hardware does my own Arbitrum One node need, and what Ethereum access does it need as well?”
- “How many nodes do I need for 99.9 per cent availability, and which client is good for client diversity?”
How the connection works and what MCP can do in your own business is explained on the page about MCP integrations.
10 / COMMON QUESTIONS
Common questions about nodes, clients and RPC providers
How much storage does an Ethereum full node need?
That depends on the client and on how much history the node keeps. In the Eth Docker measurements of September 2026 1.8 TB to 2.2 TB is the range for full history, 1.2 TB to 1.4 TB for history from the Merge onwards and 429 GB to 634 GB for rolling history. The beacon node adds 15 to 90 GiB. Planned over two years, Geth with full history ends up on a 4 TB drive, which matches the recommendation in EIP-7870.
What is the difference between a full node and an archive node?
A full node checks every block and holds the current state, but keeps old states only briefly: Geth keeps the last 90,000 blocks, about 12.5 days, and Besu keeps 512 blocks by default. An archive node keeps every state since the first block. Only then can you answer “What was the balance on 1 January?” or run trace calls on old blocks. It needs 2 TB (Geth, path archive) to 14 TB (Nethermind).
Is an RPC provider enough, or do I need my own node?
For a few hundred thousand requests a day, a provider is usually enough. Your own or a dedicated node pays off from about 1,000,000 requests a day or with many heavy queries, if your users’ addresses should not end up with third parties, or if you need a lot of archive data. These thresholds are our own rules of thumb, and the planner shows them openly. From a 99.9 per cent availability target, a second access path is always required.
How long does it take to sync an Ethereum node?
With snap sync or a snapshot, according to Eth Docker, about 2 hours (Nethermind, Reth) to 13 hours (Besu); Geth about 3 hours. Without a snapshot and on older hardware, a full sync can take over two weeks. Archives take longer: Erigon quotes about 14 hours at 400 Mbit/s, Geth about two weeks for a path archive from the first block. This is also how long a rebuild after a failure takes.
What does your own Arbitrum or Base node need?
According to its documentation, Arbitrum One requires at least 64 GB of RAM and 8 cores, recommended 128 GB and 16, plus local NVMe drives; the snapshot is about 2.4 TB, and we plan for 8 TB. Base states at least 8 cores and 32 GB of RAM (64 recommended) and the disk formula 2 × chain size + snapshot + 20%, which gives 8 TB for us. Both also need access to Ethereum, as RPC and as beacon API.
Which client should I choose for client diversity?
One with a share of under a third. In the snapshot of October 2025, Geth (41%) and Nethermind (38%) were above that among execution clients, and Lighthouse (42.7%) among consensus clients. A bug in a client with more than a third can stall finality; with more than two thirds, it can finalise a wrong chain. The live figures from the sources differ widely, so it is worth checking before you choose.
What does an RPC provider see of my users?
Every query: which addresses, which contracts, and which IP address it comes from. In studies, IP address and wallet address could be linked from the timing of the queries with a hit rate of over 95 per cent, even by an observer on the network. Your own node keeps this data with you; with a dedicated node, the contract with the provider sets what it may see and store.
Where does the node planner stop?
It works from the client documentation and the Eth Docker measurements, with the date next to each figure. Growth per month, load and the capacity of a node are labelled estimates and are no substitute for a load test. We clarify with you which providers, servers and clients suit your application and how the node is monitored and rebuilt after a failure; the planner deliberately gives no prices.
11 / STUDIES AND SOURCES
What the tool is based on
The guide values and notes above are based on these 15 scientific papers. Each one has been checked via its DOI or the publisher’s page (most recently on 14 November 2026): it exists, it has not been retracted, and its findings still hold for this question today.
Cortes-Goicoechea, M.; Mohandas-Daryanani, T.; Muñoz-Tapia, J. L. et al. (2024): Can We Run Our Ethereum Nodes at Home?. IEEE Access 12, pp. 44401–44423
Finding About 30,000 CPU hours of measurement on six consensus clients: the need is higher than originally stated. Execution and consensus client together took 15 to 23 GB of RAM; during a fresh sync the CPU load rose to three to four times, and the authors expect similar peaks when finality is lacking. As a good compromise, the authors name 8 cores, 32 GB of RAM and a fast 2 TB SSD.
In the tool The planner never sets RAM below 32 GB and adds a 20 per cent buffer to the measured need.
doi.org/10.1109/ACCESS.2024.3381782 · Journal article
Cortes-Goicoechea, M.; Franceschini, L.; Bautista-Gomez, L. (2021): Resource Analysis of Ethereum 2.0 Clients. 3rd Conference on Blockchain Research & Applications (BRAINS 2021), pp. 1–8
Finding The paper compares the resource use of several beacon chain clients and shows clear differences between the implementations, as well as different reactions to disturbances in the network.
In the tool That is why the planner gives storage and RAM per client individually instead of one figure for “a node”.
doi.org/10.1109/BRAINS52497.2021.9569812 · Conference paper
Kim, J.-Y.; Lee, J.; Koo, Y. et al. (2021): Ethanos: Efficient Bootstrapping for Full Nodes on Account-Based Blockchain. Proceedings of the Sixteenth European Conference on Computer Systems (EuroSys ’21), pp. 99–113
Finding The biggest effort in setting up a full node is synchronising the state of all accounts. Over 95 per cent of accounts were dormant, yet the state keeps growing; many users therefore rely on other people’s full nodes.
In the tool The planner calculates state growth separately and shows that it remains even with rolling history.
doi.org/10.1145/3447786.3456231 · Conference paper
Yang, R.; Murray, T.; Rimba, P. et al. (2019): Empirically Analyzing Ethereum's Gas Mechanism. IEEE European Symposium on Security and Privacy Workshops (EuroS&PW), pp. 310–319
Finding Analysis of terabytes of execution traces: input and output on the storage device shape the cost of a transaction more than the gas model reflects, and less well-equipped nodes are at a disadvantage as a result.
In the tool The planner calls for NVMe SSDs rather than hard disks and gives the clients’ IOPS requirements.
doi.org/10.1109/EuroSPW.2019.00041 · Conference paper
Kim, S. K.; Ma, Z.; Murali, S. et al. (2018): Measuring Ethereum Network Peers. Proceedings of the Internet Measurement Conference (IMC ’18), pp. 91–104
Finding P2P network measured over three months: fewer than half of the nodes found contributed to the Ethereum mainnet at all; the network is noisy and differs in size and distribution from other P2P networks.
In the tool This leads to the advice to monitor the number of usable peers rather than just “is the process running”.
doi.org/10.1145/3278532.3278542 · Conference paper
Heo, H.; Woo, S.; Yoon, T. et al. (2023): Partitioning Ethereum without Eclipsing It. Network and Distributed System Security Symposium (NDSS 2023)
Finding Anyone who controls about half the peer connections of a Geth full node (around 25 of 50) can cut it off from the rest of the network for hours with a slow disruption attack, while the node otherwise carries on running normally. A countermeasure came in Geth 1.11.0.
In the tool The planner recommends monitoring the distance to the chain head; a node that has fallen behind delivers old data without failing.
doi.org/10.14722/ndss.2023.24465 · Conference paper
Li, K.; Chen, J.; Liu, X. et al. (2021): As Strong As Its Weakest Link: How to Break Blockchain DApps at RPC Service. Network and Distributed System Security Symposium (NDSS 2021)
Finding All nine Ethereum RPC services examined could be deliberately slowed down in April 2020 without fees; a local node was slowed by 91 per cent in synchronisation at 150 requests per second. At least 63 per cent of Ethereum DApps depended on a single RPC service.
In the tool That is why a second way in belongs with an availability target from 99.9 per cent, and high load favours your own or a dedicated node.
doi.org/10.14722/ndss.2021.23108 · Conference paper
Luo, Z.; Murukutla, R.; Kate, A. (2022): Last Mile of Blockchains: RPC and Node-as-a-service. IEEE 4th International Conference on Trust, Privacy and Security in Intelligent Systems, and Applications (TPS-ISA), pp. 305–311
Finding The position paper compares the ways of access, from your own full node to someone else’s service, by integrity, availability and privacy. Result: all three properties together are secured today only by your own full node.
In the tool These three properties are the axes of the recommendation: load, privacy and availability target.
doi.org/10.1109/TPS-ISA56441.2022.00044 · Conference paper
Wang, S.; Yang, M.; Dai, W. et al. (2024): Deanonymizing Ethereum Users behind Third-Party RPC Services. IEEE INFOCOM 2024 – IEEE Conference on Computer Communications, pp. 1701–1710
Finding From the size of encrypted packets and the time intervals of transactions, a user’s Ethereum address could be linked to their IP address when they send through someone else’s RPC service: with a hit rate of 98.7 per cent on the testnet and 96.6 per cent on the mainnet.
In the tool Basis for the privacy note for provider and dedicated node.
doi.org/10.1109/INFOCOM52122.2024.10621236 · Conference paper
Wang, S.; Yang, M.; Liu, Y. et al. (2025): Time Tells All: Deanonymization of Blockchain RPC Users with Zero Transaction Fee. Proceedings of the 2025 ACM SIGSAC Conference on Computer and Communications Security (CCS ’25), pp. 3490–3504
Finding A passive observer at the network node links the IP address and wallet address of an RPC user purely from the times at which they ask for the status of their transaction, without any fees of their own. The success rate was over 95 per cent, on Ethereum, Bitcoin and Solana.
In the tool If privacy is ticked, the planner advises your own or a dedicated node rather than shared access.
doi.org/10.1145/3719027.3765082 · Conference paper
Chatzigiannis, P.; Baldimtsi, F.; Chalkias, K. (2022): SoK: Blockchain Light Clients. Financial Cryptography and Data Security (FC 2022), LNCS, pp. 615–641
Finding Anyone who cannot load the whole chain otherwise has to trust other people’s servers. Light clients close the gap: they query and send without storing the chain, and keep its security properties. The paper sorts the designs by function, effort and security.
In the tool With the recommendation “provider”, the planner names the light client as a way to check the answers yourself.
doi.org/10.1007/978-3-031-18283-9_31 · Review
Kim, S.; Hwang, S. (2023): EtherDiffer: Differential Testing on RPC Services of Ethereum Nodes. 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE ’23), pp. 1333–1344
Finding Four large node implementations did not always answer the same RPC calls in the same way, above all with invalid arguments and unclear cases in the specification. The testing tool found 48 classes of such deviations.
In the tool The tool therefore advises testing queries against every client in use before two different ones run behind a load balancer.
doi.org/10.1145/3611643.3616251 · Conference paper
Zhong, Z.; Nan, Y.; Ye, M. et al. (2026): Is My RPC Response Reliable? Detecting RPC Bugs in Blockchain Client under Context. Proceedings of the 2026 IEEE/ACM 48th International Conference on Software Engineering (ICSE), pp. 3661–3672
Finding RPC bugs in blockchain clients often show only in a particular state of the chain and can trigger unexpected answers, up to the failure of the service; earlier tests miss such context-dependent bugs.
In the tool Supports the advice to test with your own contracts and queries after a change of client or an update, not just with sample calls.
doi.org/10.1145/3744916.3773103 · Conference paper
Pavloff, U.; Amoussou-Guenou, Y.; Tucci-Piergiovanni, S. (2024): Byzantine Attacks Exploiting Penalties in Ethereum PoS. 54th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN), pp. 53–65
Finding In May 2023, the “inactivity leak” took effect on Ethereum for the first time; it is meant to restore finality after prolonged disruption. The analysis shows that under this mechanism attackers can get past the critical one-third threshold and two conflicting branches can be finalised.
In the tool Shows why the one-third limit in client diversity is more than a recommendation, and carries the note in the result.
doi.org/10.1109/DSN58291.2024.00020 · Conference paper
Ron, J.; He, Z.; Monperrus, M. (2026): Proving and Rewarding Client Diversity to Strengthen Resilience of Blockchain Networks. Distributed Ledger Technologies: Research and Practice 5 (4), pp. 1–22
Finding Most blockchain networks have a skewed distribution of client implementations; if a majority client fails, major losses are possible. Using a modified Lighthouse, the authors show how the use of a minority client could be verified and rewarded.
In the tool The planner marks clients with a share above 33 per cent and, where it fits, advises a minority client.
doi.org/10.1145/3773288 · Journal article
Standards, authorities and manufacturer data
- Spin up your own Ethereum node (hardware, disk space per client) (updated 29.10.2026) · ethereum.org
- Client Resource Usage (disk, RAM, sync time) (measurements February to September 2026) · Eth Docker
- EIP-7870: Hardware and Bandwidth Recommendations (living document, created 26.01.2025) · Ethereum Improvement Proposals
- EIP-8037: State Creation Gas Cost Increase (state growth) (Last Call, measurements from January 2026) · Ethereum Improvement Proposals
- Geth: Archive nodes (edited 24.02.2026) · go-ethereum
- Geth: Hardware requirements (edited 14.09.2023) · go-ethereum
- Geth: Command-line options (--history.state) (edited 16.05.2025) · go-ethereum
- Nethermind: System requirements (version 2.2.0, updated 05.11.2026) · Nethermind
- Besu: System requirements (updated 06.11.2026) · Besu
- Besu: Data storage formats (Bonsai, Forest) (updated 06.11.2026) · Besu
- Erigon: Hardware requirements (v3.8, updated 11.11.2026) · Erigon
- Reth: System requirements (figures of 23.06.2025) · Paradigm / Reth
- Lighthouse Book: Installation (system requirements) (undated, retrieved 14.11.2026) · Sigma Prime
- Teku: System requirements (version 26.10.1) · Consensys
- Nimbus Guide: System requirements (undated, retrieved 14.11.2026) · Status / Nimbus
- Arbitrum: Run a node, start here (hardware) (Nitro v3.12.2, retrieved 14.11.2026) · Offchain Labs
- Arbitrum: Run a full node (Snapshots, PathDB) (retrieved 14.11.2026) · Offchain Labs
- Arbitrum: Run an archive node (retrieved 14.11.2026) · Offchain Labs
- OP Stack: Run a node with Docker (op-reth v2.2.5, retrieved 14.11.2026) · Optimism
- OP Stack: Archive node (retrieved 14.11.2026) · Optimism
- Base: Run a Base node (base/base v1.5.x, retrieved 14.11.2026) · Base
- Base: Node performance (hardware) (retrieved 14.11.2026) · Base
- Polygon PoS: Prerequisites (hardware) (undated, retrieved 14.11.2026) · Polygon
- Polygon PoS: Full node with binaries (retrieved 14.11.2026) · Polygon
- Client diversity (updated 23.02.2026, figures October 2025) · ethereum.org
- Client Diversity (live overview of several sources) (retrieved 14.11.2026) · clientdiversity.org
- MetaMask Privacy Notice (Infura as default RPC) (revised 01.10.2026) · Consensys / MetaMask
12 / MORE TOOLS
Still have a question?
- AT-W32 · Businesses
Blockchain suitability check
Does your project really need a blockchain, or will a database do? - AT-W33 · Businesses
MiCA check
Does your token fall under MiCA, and what obligations follow from that? - AT-W34 · Home & business
Gas calculator
What does a transaction cost on Ethereum, Arbitrum, Optimism, Base or Polygon? - AT-W35 · Home & business
Ethereum address checker
Is this Ethereum address valid and correctly written? EIP-55 checksum and comparison of two addresses. - AT-W36 · Businesses
Selector and topic calculator
Which function selector or event topic belongs to this Solidity signature, and the other way round? - AT-W37 · Businesses
Calldata decoder
What does this transaction do? Make calldata readable before you sign.
Got your figures? Send us the copied result. We run nodes and data feeds for your application or connect a suitable provider, and we tell you beforehand which option is sufficient for your load.
+49 3744 4399760[email protected]Mon–Fri 8:00–17:00 · Straße der Jugend 5, 08228 Rodewisch