Ethereum Node: What It Actually Takes to Run One
An Ethereum node is software that keeps a copy of the Ethereum chain, validates new blocks and relays transactions on the peer-to-peer network. A full setup pairs an execution client with a consensus client. Per ethereum.org, it needs at least a 2 TB NVMe SSD and 16 GB of RAM.
You do not need your own Ethereum node to send ETH or ERC-20 tokens or to watch deposits, because a REST API covers that. You need one to validate, to index the full chain or to run archive queries. The numbers below come from ethereum.org's node documentation, checked on 5 November 2026, not from a sales page.
Searching for "ethereum node" usually means one of two things. Either you want to know what running one involves before you commit server budget, or you want to test the assumption that a node is the only way to read and send Ethereum data. This page answers both.
What is an Ethereum node?
An Ethereum node is a running instance of client software that stores the chain, validates new blocks and relays transactions to the peer-to-peer network. Since the Merge, a full setup pairs two programs. An execution client such as Geth, Nethermind, Besu, Erigon or Reth handles state and transactions. A consensus client such as Lighthouse, Prysm, Teku, Nimbus or Lodestar handles proof-of-stake attestations. Both run continuously and talk to each other over a local RPC connection.
Nodes come in three storage profiles, described on ethereum.org. Full nodes keep recent state and prune old data. Archive nodes keep every historical state ever written. Light nodes download only block headers and ask a full node for anything else.
What are the Ethereum node requirements?
For a full node running one execution and one consensus client, ethereum.org lists the minimum in the left column. The right column is the hardware guidance it takes from EIP-7870. Both were checked on 5 November 2026.
| Component | Minimum | Recommended for a full node |
|---|---|---|
| CPU | 2+ cores | Fast CPU, 4+ cores (8+ if validating) |
| RAM | 16 GB (32 GB for stability) | 32 GB (64 GB if validating) |
| Storage | 2 TB NVMe SSD | 4 TB NVMe SSD |
| Bandwidth | 25+ Mbit/s | 50 Mbit/s down, 15+ Mbit/s up |
Three details are easy to miss when sizing a server. First, storage depends on the client. With snap sync, Geth and Nethermind need roughly 500 GB and Besu 800 GB for execution data. An archive node runs 12 TB or more on Geth, Nethermind and Besu, and about 2.2 to 2.5 TB on Reth and Erigon, which store state differently.
Second, the consensus client is a separate budget line. Plan for roughly another 200 GB of beacon data. Third, none of this is a one-time cost, because disk usage grows for as long as the node stays online.
Sync time depends on hardware, network speed and sync mode. The official docs publish no fixed duration, and neither do we, so treat any day count you find elsewhere as a guess.
How do I run an Ethereum node?
Running a node is a set of ongoing responsibilities, not a single install step. Pick a matched execution and consensus client pair. Provision the hardware from the table above. Start both clients, point them at each other's local RPC endpoints, and let the initial sync finish before you rely on the node.
After that the job is operational. Apply client updates promptly, because hard forks require it. Monitor peer count and disk headroom, and keep the machine reachable around the clock. A node that stays offline for long has to catch up before it is useful again.
For a step-by-step build with commands, Geth and Lighthouse configuration and systemd units, see the Ethereum node setup guide on the blog.
Can an Ethereum node run on a Raspberry Pi?
Yes, within limits. Ethereum.org points to Ethereum on ARM, which ships ready-made images of several clients for Raspberry Pi and other ARM boards. The same page notes the limited performance of such devices.
ARM does not change the requirements table above. The storage footprint and the RAM floor stay the same, and a slower CPU tends to stretch the initial sync. ARM is a way to run a node more cheaply and quietly at home, not with fewer resources.
Self-hosted node vs. Chaingateway API
Both give you Ethereum data and the ability to send transactions. What differs is who carries the operational load.
| Your own Ethereum node | Chaingateway API | |
|---|---|---|
| Setup | Install, configure and sync two clients | Register and get an API key |
| Storage | 2 TB+ NVMe SSD, growing every month | None on your side |
| Sync | Hardware-dependent, no published duration, repeated after long downtime | Not applicable, always synced |
| Uptime | Your responsibility, 24/7 | Covered by the service |
| Client upgrades | Applied by you, on the hard-fork schedule | Handled centrally |
| What you get | Full JSON-RPC surface, including archive queries if configured | REST endpoints for addresses, ERC-20/721 transfers and deposit webhooks |
The API does not need to reimplement the whole JSON-RPC surface to cover what most integrations hire a node for: create an address, send a token, get notified when a deposit arrives. That is the Ethereum API in one sentence.
When do I actually need my own Ethereum node?
You need one when you run a validator, index the full chain for analytics, need archive-level historical state, or have a compliance rule that chain access must not depend on a third party. An API does not replace those jobs.
If your requirement is narrower, the picture changes. Generating deposit addresses, sending ETH or ERC-20 tokens and learning when money arrives is the exact surface a payments API is built for, without the storage and uptime commitment.
If your actual requirement is sending ERC-20 tokens and watching deposits, create a free account and try the same job over REST before you provision 2 TB of SSD.
The node-free version: create an address and send an ERC-20 token
No RPC endpoint, no client pair to keep synced — one Bearer token in the Authorization header.
curl -X POST https://app.chaingateway.io/api/v2/ethereum/addresses \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json"
curl -X POST https://app.chaingateway.io/api/v2/ethereum/transactions/erc20 \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"contractaddress": "0xdAC17F958D2ee523a2206206994597C13D831ec7",
"from": "0xYourHotWallet",
"to": "0xRecipient",
"amount": 100,
"password": "YourWalletPassword"
}'Sources
- Run your own Ethereum node (ethereum.org)
- Nodes and clients (ethereum.org)
- EIP-7870: Hardware and Bandwidth Recommendations
Checked on 5 November 2026.
FAQ: Ethereum nodes
Skip the node, keep the data
Create an account and send a testnet ERC-20 transfer in minutes — 7-day trial, no card, no KYC. The full endpoint set is in the Ethereum API reference, and every chain is covered by the multi-chain blockchain API.
Reviewed by Maurice Sobiera How we write these pages