Node vs. API, honestly compared

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.

7-day free trial — no card, no KYC to start Non-custodial — private keys stay under your control Plans start at €49/month (€490/year) — view plans and rate limits

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.

Your own node Chaingateway API Your application backend or wallet Execution + consensus clients, kept updated 2 TB+ NVMe SSD sync, disk growth, uptime Your application backend or wallet REST API one Bearer token Ethereum network
Same destination, different operating load. With the API there is no client or disk on your side.

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.

ComponentMinimumRecommended for a full node
CPU2+ coresFast CPU, 4+ cores (8+ if validating)
RAM16 GB (32 GB for stability)32 GB (64 GB if validating)
Storage2 TB NVMe SSD4 TB NVMe SSD
Bandwidth25+ Mbit/s50 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 nodeChaingateway API
SetupInstall, configure and sync two clientsRegister and get an API key
Storage2 TB+ NVMe SSD, growing every monthNone on your side
SyncHardware-dependent, no published duration, repeated after long downtimeNot applicable, always synced
UptimeYour responsibility, 24/7Covered by the service
Client upgradesApplied by you, on the hard-fork scheduleHandled centrally
What you getFull JSON-RPC surface, including archive queries if configuredREST 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
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

Checked on 5 November 2026.

FAQ: Ethereum nodes

Client software that stores the Ethereum chain, validates blocks and relays transactions on the peer-to-peer network. A full setup pairs an execution client with a consensus client, running continuously on hardware you provision and maintain.

Install a matched execution and consensus client pair, provision hardware that meets the current minimums (2 TB NVMe SSD and 16 GB RAM as a floor per ethereum.org), let the initial sync finish, then keep both clients online, updated and monitored. The full walkthrough with commands is in the setup guide linked above.

Ethereum.org's guide (checked 5 November 2026) lists 2+ CPU cores, 16 GB RAM, a 2 TB NVMe SSD and 25+ Mbit/s bandwidth as the minimum. For a full node it points to EIP-7870, which recommends 4+ cores, 32 GB RAM, a 4 TB NVMe SSD and 50 Mbit/s down. Archive nodes need substantially more: 12 TB+ on Geth, Nethermind or Besu, or 2.2 to 2.5 TB+ on Reth or Erigon.

No. Creating an address, sending ETH or an ERC-20 token and getting notified about a deposit are exactly the operations the Ethereum API covers over REST, without a synced node behind your own server.

Yes, ethereum.org points to Ethereum on ARM for ready-made images for Raspberry Pi and other ARM boards, and notes their limited performance. The storage and RAM requirements do not shrink for ARM, it is a cheaper, quieter way to meet the same requirements.

It depends on hardware, network speed and sync mode, and the official documentation does not publish a fixed duration. Faster storage and a wired connection shorten it, while undersized disks and a metered connection lengthen it unpredictably.

A full node keeps recent state and prunes older data, which is what the table above sizes for. An archive node keeps every historical state the chain has ever had, which is why its storage requirement jumps to 12 TB or more on most clients.

No. Everything on this page is about the blockchain-infrastructure meaning of node: client software that syncs and validates the chain. If you landed here looking for a physical kit or an unrelated product, this isn't that. The closest thing this site covers is the software and hardware described above.

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