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

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.

Step 1Which network does your application run on?
Step 2What do you need access for?

You can select more than one.

Step 3How far back do you need blocks, receipts and logs?

On Ethereum, this decides how much history the node keeps.

Step 4How many requests will there be?

All JSON-RPC calls together; shown in your provider’s dashboard or in your backend’s log.

Heavy: eth_getLogs over many blocks, trace_* and debug_trace*. Not sure? 5% is a usual value for dashboards.

Step 5How should it run?

Recommendation

—

Choose at least one purpose.

Runs in your browser. Nothing is sent or stored.

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 types on Ethereum, disk across five execution clients
Node typekeepsDriveenough for
Full node, rolling historycurrent state, blocks and receipts of the last 147 days or so429 GB bis 634 GBbalances, eth_call, sending, events of the last few months
Full node, history from the Mergecurrent state, blocks and receipts since 15.09.20221.2 TB to 1.4 TBevents and receipts since September 2022
Full node, full historycurrent state, all blocks and receipts since 20151.8 TB to 2.2 TBevents and receipts since 2015, for contracts from before the Merge, for example
Archive nodeplus every old state since the first block2 TB bis 14 TBstate 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.

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).

Execution clients, Ethereum Mainnet
Clientfullfrom MergerollingarchiveRAM measured / docsSync
Geth 1.17.5over 1.7 TiBabout 1.3 TiBnot supportedabout 2 TB (path archive, state history only)about 8 GiB Docs: at least 16 GBabout 3 hours (snap sync, 1.17.2, April 2026)
Nethermind 2.0.0about 1.6 TiBabout 1.2 TiBabout 450 GiBat 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 IOPSabout 2 hours (1.36.0, February 2026), ready for attestations after about 1 hour
Besu 26.8.1over 1.7 TiBabout 1.1 TiBabout 430 GiBabout 12 TB (Forest, undated)about 10 GiB Docs: JVM at least 8 GB; reference: 8 vCPU and 30 GiBabout 13 hours (rolling, 26.1.0, February 2026)
Erigon 3.6.0about 1.6 TiBabout 1.1 TiBabout 590 GiB2.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 recommendedabout 12 hours (rolling, 3.3.8, February 2026); Erigon docs: full mode about 5 h 40 min at 400 Mbit/s
Reth 2.5.2about 2 TiB (with receipts)about 1.2 TiBabout 400 GiBat least 2.8 TB (as of 23.06.2025)about 14 GiB Docs: 8 GB+ (full), 16 GB+ (archive), 16 GB recommended in generalabout 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).
00.5 TB1 TB1.5 TB2 TBGETHARCHIVE 2 TBNOT SUPPORTED1.4 TB1.9 TBNETHERMINDARCHIVE 14 TB483 GB1.3 TB1.8 TBBESUARCHIVE 12 TB462 GB1.2 TB1.9 TBERIGONARCHIVE 2.3 TB634 GB1.2 TB1.8 TBRETHARCHIVE 2.8 TB429 GB1.3 TB2.2 TBROLLINGFROM MERGEFULL

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)

Consensus clients; Lighthouse, Prysm and Lodestar measured without collected blob data
ClientmeasuredDatabaseRAMFigure in the docs
Lighthouse 8.2.2September 2026about 15 GiBabout 14 GiBWith execution client: 32 GB RAM (16 GB “quite tight”), four cores, 2 TB SSD, 100/20 Mbit/s
Prysm 7.1.3April 2026about 20 GiBabout 9 GiBThe hardware page of the docs was unavailable on 14.11.2026
Teku 26.4.0April 2026about 80 GiBabout 10 GiBFull 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.0September 2026about 90 GiBabout 5 GiBBeacon node: 4 GB RAM, 200 GB; with execution client: 2 TB SSD, 16 GB RAM
Lodestar 1.42.0April 2026about 20 GiBabout 12 GiBBeacon 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.

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.

L2 and sidechain nodes according to the docs
NetworkFull nodearchiveRAM / CPUEthereum access
Arbitrum One Nitro v3.12.2Snapshot 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 recommendedEthereum 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.5about 700 GBaccording to the docs “several terabytes”not stated not statedEthereum 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 performanceown Ethereum access (full-node RPC) and beacon API, not a Base endpoint
Polygon PoS Heimdall + Bor (archive: Erigon)4 TB minimum, 6 TB recommended16 TB (Erigon)32 GB minimum, 64 GB recommended 8 cores minimum, 16 recommendedEthereum 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.

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.

Permitted downtime per month against the duration of a rebuild (full node measured by Eth Docker on 96 GiB of RAM and 20 vCPUs)
TargetDowntime/monthFull node (2 to 13 h)Archive (14 h to 2 weeks)
99 %7.3 hourstight, fallbacksecond node needed
99,5 %3.7 hourstight, fallbacksecond node needed
99,9 %44 minutessecond node neededsecond node needed
99,99 %4.4 minutessecond node neededsecond 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.

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.

Execution clients, October 2025
ClientShareAssessment
Geth41 %over a third
Nethermind38 %over a third
Besu16 %under a third
Erigon3 %under a third
Reth2 %under a third
Consensus clients, October 2025
ClientShareAssessment
Lighthouse42,7 %over a third
Prysm30,9 %under a third
Teku13,9 %under a third
Nimbus8,7 %under a third
Lodestar2,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.

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.

How to plan access to the chain

  1. 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.
  2. Choose the node type. Old state needs an archive, old events only the right history. That saves terabytes.
  3. Choose the client. Disk and RAM from the table, plus the share: where it fits, one under a third.
  4. 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.
  5. Set up a fallback. A second node with a different client or a provider as reserve, depending on the availability target.
  6. 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.

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
Inputs
NameRequiredMeaning
chainyesNetwork: ethereum = Ethereum Mainnet; arbitrum = Arbitrum One; op = OP Mainnet; base = Base; polygon = Polygon PoS.
zweckeyesWhat 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).
rueckblicknoHow 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_tagyesJSON-RPC requests per day, all methods together.
spitzenfaktornoRatio of peak load to average (e.g. 5 = at peak five times as many requests per second). If omitted, 5.
anteil_schwer_prozentnoShare of heavy queries in per cent (eth_getLogs over many blocks, trace_*, debug_trace*). If omitted, 5.
verfuegbarkeit_prozentnoAvailability target in per cent, e.g. 99, 99.5, 99.9 or 99.99. If omitted, 99.9.
datenschutz_wichtignotrue if queried addresses and users’ IP addresses should not end up with a third-party provider. If omitted, false.
eigenes_betriebsteamnotrue if your own team can update, monitor and rebuild nodes. If omitted, false.
planungs_monatenoPeriod 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.

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.

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.

  1. 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.

  2. 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”.

  3. 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.

  4. 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.

  5. 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”.

  6. 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.

  7. 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.

  8. 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.

  9. 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.

  10. 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.

  11. 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.

  12. 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.

  13. 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.

  14. 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.

  15. 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.

Standards, authorities and manufacturer data

Mon–Fri 8:00–17:00

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

Request node operation
+49 3744 4399760Mon–Fri 8:00–17:00
CallCallback

PARTS LIST · SHEET 1/1

What this page is made of

Values measured at build time. With JavaScript, your browser measures them again live.

ITEMPARTTYPESIZE
01index.htmlDocument≈ 29 kB
02styles.cssStylesheet≈ 20 kB
03scripts.jsScript≈ 13 kB
04archivo-variable.woff2Font≈ 58 kB
05ibm-plex-mono.woff2Font≈ 30 kB
06favicon.svgImage< 1 kB

Advertising or analytics cookies: none. Without your consent, the page loads nothing from third-party servers apart from Cloudflare, our delivery service. Fonts, scripts and images are hosted by us. That is how we build your IT, too.

OUTSIDE OFFICE HOURS

Feel free to call anyway

Our regular office hours are Monday to Friday, 8:00–17:00.

In the evening and at weekends the number is forwarded to us, and often someone will pick up. We cannot promise that, though.

If nobody answers, leave a short message on the voicemail: your name, your number and what it is about. We will call back as soon as we can, on the next working day at the latest.

The call costs nothing. If someone has to start work straight away outside office hours, the surcharge in the price list applies.

Call now+49 3744 4399760

Prefer to write? Use the contact form or e-mail [email protected]. We will read it on the next working day.

DIAGNOSIS · AT-K2

What do you need help with?

↵ SELECTESC CLOSECALL: +49 3744 4399760

Custom settings

Which services may load?

Strictly necessary

The choice you make here and your settings for colour scheme and motion. These are kept as small entries on your device and are never sent to a server. They are needed for the site to work and therefore cannot be switched off.