A blockchain node is any computer running that network’s software, holding a copy of the ledger, and helping check that new transactions follow the rules. Some nodes just watch and relay data; others also produce blocks, store the network’s entire history, or stake money to vote on what counts as valid. That range is exactly why “node” alone doesn’t tell you much — the type does.
This guide moves from the basic idea to what actually matters in practice: what a node does, why networks need so many of them, and who runs one. From there, it works through the main types — full, light, archive, pruned, mining, validator, masternode, and RPC — down to the trade-offs that separate them.
What Does a Node Actually Do?
A node’s core job is small: check incoming data against the network’s rules, then pass it along. Every time someone broadcasts a transaction, nodes across the network verify the signature is valid, the sender has the funds, and the transaction doesn’t conflict with anything already recorded — before relaying it further.
Ethereum’s own documentation defines it plainly: a node is “any instance of Ethereum client software that is connected to other computers also running Ethereum software, forming a network.” The client is the actual program doing the checking — Geth and Nethermind on Ethereum, Bitcoin Core on Bitcoin, and similar software on other chains — according to ethereum.org.
That’s the mechanic underneath every blockchain, not just Ethereum’s. A crypto node doesn’t trust a central server to say a transaction is real — it checks the math itself, using the same rules as every other node in the network. Multiply that by thousands of independent machines, and you get a ledger nobody can quietly rewrite.
Why Do Blockchains Need So Many of Them?
Here’s the problem a spread-out network of nodes actually solves: with no bank or company in the middle, something still has to stop people from spending the same coins twice or rewriting history after the fact. A single node could lie. Thousands of independent ones, all checking the same rules, are far harder to fool at once.
Right now, coin.dance counts 26,430 public Bitcoin nodes, and ethernodes.org tracks just over 8,000 public Ethereum execution nodes, as of August 2026. Neither figure counts nodes running privately behind a firewall or VPN, so the real total is higher — the visible count alone is already enough independent checking to make quietly rewriting old transactions practically impossible.
Jimmy Song, a Bitcoin educator and the author of the Bitcoin Tech Talk newsletter, puts the reasoning plainly:
“By running a full node, users don’t have to trust anyone. They can verify for themselves that the transaction is legit and that they are not getting screwed.” — Jimmy Song, Bitcoin Tech Talk
Skip that step, and you’re trusting whatever a wallet app or block explorer tells you instead — precisely the single point of failure a distributed network exists to avoid. It’s not free, either: spreading validation across more independent machines is part of the same balancing act covered in the blockchain trilemma, where networks trade decentralization against speed and cost.
Who Runs Them, and Who Just Connects to One?
Not everyone touching a blockchain or cryptocurrency network runs a node themselves, and that split matters for how the ecosystem actually works. A handful of groups operate the machines directly:
- Individuals and hobbyists, running a node for privacy, sovereignty, or simply to stop trusting someone else’s copy of the ledger.
- Miners and validators, who need a node running as a baseline before they can produce blocks and earn rewards.
- Exchanges, wallets, and block explorers, which need constant, reliable access to chain data to serve their own users.
- Developers building dApps, who need to read blockchain state and broadcast transactions from their application.
Most of that last group never touches server maintenance directly. A team typically connects through a provider’s API instead — NOWNodes, for instance, offers shared and dedicated node access across 120-plus networks, so an app can reach dozens of chains through one account rather than running a separate stack for each.
Full Nodes, Light Nodes, and Every Category in Between
Now for the different types of nodes in blockchain networks. Every category below solves the same basic problem — checking blockchain data against the rules — but trades off storage, hardware, and responsibility differently.
Full Nodes
A full node downloads and independently validates every block, checking each transaction against the network’s consensus rules instead of trusting someone else’s word for it. If a block breaks those rules — even one produced by a large mining pool or validator — a full node rejects it outright.
Full node: software that stores a blockchain’s current state, validates every incoming block and transaction against protocol rules, and relays valid data to its peers. See ethereum.org’s node documentation.
Running one isn’t exotic. Ethereum’s official guidance lists a minimum of 4–8 GB of RAM and a 2 TB SSD, on hardware as ordinary as a small NUC-style PC, according to ethereum.org.
Not every full node runs the same client software, either. On Ethereum, Geth alone accounts for roughly 40% of tracked execution nodes — a concentration the Ethereum Foundation actively discourages, since a bug in the dominant client could disable a disproportionate share of the network at once, per ethernodes.org and clientdiversity.org.
Light Nodes
A light node — also called a light client — downloads only block headers instead of full blocks, then asks a full node to fill in the details when needed. That trade cuts storage from hundreds of gigabytes down to a few hundred megabytes, which is why mobile wallets and browser extensions lean on this model instead of full validation.
The catch is trust. A light node verifies a header cryptographically, but for the transaction data itself, it relies on whichever full node answered its request — a small, usually reasonable risk for everyday use, and a real one if that full node is lying.
Archive Nodes
An archive node is a full node that never throws anything away. A standard full node on most chains eventually discards older raw data once it’s no longer needed for validation; an archive node keeps every historical state since the genesis block instead — every past balance, every old contract call, all of it.
That completeness is expensive. Syncing an Ethereum archive node with the Erigon client takes roughly 2 TB of disk space and under three days on capable hardware, according to ethereum.org — overkill unless you’re running a block explorer, an analytics platform, or something that genuinely needs to query old chain history.
Pruned Nodes
A pruned node does everything a full node does — downloading and checking every block against the rules — then deletes the older raw block data once it’s finished with it, keeping only the current state. Bitcoin Core ships this as a built-in -prune option, so a node can fully validate the chain in real time while keeping a few gigabytes on disk instead of several hundred.
This is the type most “just run a node” guides skip over, and it’s often the more realistic choice for an individual: full validation, without the archive node’s storage bill.
Mining Nodes
On proof-of-work networks like Bitcoin, a mining node is a full node with extra hardware bolted on, competing to solve a computational puzzle for the right to add the next block. Every miner runs a full node underneath, but not every full node mines — most just validate and relay.
Validator Nodes
Proof-of-stake networks replace mining with staking: a validator node locks up the network’s token as collateral, then proposes and confirms blocks instead of racing to solve a puzzle. Ethereum alone runs more than 1.2 million of them, securing roughly a third of all circulating ETH, according to CoinLaw’s 2026 staking data.
The mechanics of staking, rewards, and slashing are involved enough to deserve their own explanation — see what a validator node actually does for the full breakdown.
Masternodes
A masternode is a full node with an extra job — a model Dash popularized in 2014. It provides a network service such as instant transactions, privacy, or governance voting in exchange for a share of block rewards, and typically requires locking up far more collateral than a regular validator.
RPC and API Nodes
An RPC node is simply a full or archive node exposed through an API, so an application can send it a request — check a balance, broadcast a transaction, read a smart contract — without running any blockchain software itself. This is the layer nearly every wallet, exchange, and dApp actually talks to, whether or not the team building it knows the term.
Here’s how those categories actually compare side by side:
| Node Type | What It Stores | Validates Independently | Earns Rewards | Typical Operator |
|---|---|---|---|---|
| Full node | Current state, recent blocks | Yes | No | Individuals, businesses |
| Light node | Block headers only | Partially — trusts full nodes for data | No | Mobile wallets, apps |
| Archive node | Full history since genesis | Yes | No | Explorers, analytics platforms |
| Pruned node | Current state only | Yes | No | Individuals, businesses |
| Mining node | Same as full node | Yes | Yes — block reward | PoW miners |
| Validator node | Same as full node, plus stake | Yes | Yes — staking reward | PoS validators, staking pools |
| Masternode | Same as full node, plus service layer | Yes | Yes — service reward | Collateral holders |
| RPC node | Varies by underlying node | Yes | No, unless also mining or staking | Infrastructure providers |
Full Node vs. Light Node vs. Validator: How They Actually Differ
These three get confused most often, mainly because a validator is technically a full node with an extra job attached:
| Full Node | Light Node | Validator Node | |
|---|---|---|---|
| Stores the full ledger | Yes | No | Yes |
| Independently checks every rule | Yes | No — trusts full nodes for data | Yes |
| Requires staked funds | No | No | Yes |
| Earns rewards | No | No | Yes |
| Realistic on a phone | No | Yes | No |
Every validator is a full node, but the reverse isn’t true — plenty of full nodes exist purely to validate and relay, with no stake and no reward attached. A light node sits at the opposite end: it never independently confirms the network’s history, it just trusts the math on headers and leans on full nodes for everything else. Which one fits depends on what you’re optimizing for: a phone wallet wants speed, not sovereignty; a business handling other people’s funds usually wants the opposite.
Do You Need to Run One Yourself?
For most individuals and businesses, no — that’s a deliberate design feature, not a workaround. A network only specialists could check would defeat the point of decentralization, so every major chain offers a way to use it without hosting the infrastructure.
Three realistic paths exist instead of running your own. Free public endpoints suit prototyping, not production — NOWNodes’ public tier, for example, caps out at 5 requests per second. Shared access through a provider covers most real applications by pooling infrastructure across customers, while a dedicated node gives one customer an isolated instance with no queue to compete against.
NOWNodes offers all three tiers across 120-plus networks, with archive access and Trace/Debug methods on supported chains for deeper transaction inspection. Running your own is still worth it for genuine sovereignty or contributing to network decentralization — but for everything else, the real question isn’t whether to run a node, it’s whether that node needs to be yours.
If you do decide to run one, syncing it correctly is the part most guides skip over.
Conclusion
Strip away the branding differences between chains, and every node type is answering the same question: how much of the network’s history do you need to hold, and what are you willing to trade for it. A full node buys independence at the cost of disk space, while a light node buys convenience at the cost of trusting someone else’s data — and an archive node simply pushes the full node’s trade further, buying total history at a genuinely large storage bill.
None of that makes one type objectively correct. It makes the choice worth understanding before picking infrastructure — whether that means syncing a full node yourself, staking through a validator, or connecting to one through a provider instead of running the hardware at all.
FAQ
Is a Node the Same Thing as a Wallet?
No. A wallet manages your private keys and signs transactions; a node validates and relays data on the network. Most wallets don’t run a node at all — they connect to one through a provider instead.
Do All Blockchains Have the Same Node Types?
No. Bitcoin and other proof-of-work chains have no validator nodes, since they use mining instead of staking, and Ethereum dropped mining entirely at the Merge in 2022. Which categories apply to a given chain depends on the consensus mechanism it runs.
Do You Need to Know How to Code to Run a Node?
Not for most networks. Client software like Bitcoin Core or Geth comes with installers and documentation built for non-programmers, though comfort with the command line makes troubleshooting considerably easier.
Does Running a Plain Full Node Earn You Any Money?
No. A standard full node earns nothing — it validates and relays data as a public service to the network. Only mining and validator nodes earn rewards, because they also do the extra work of producing blocks.
What Happens to the Network When Some Nodes Go Offline?
Very little, as long as enough others stay up. That resilience is the point of spreading validation across thousands of independent machines instead of a handful of servers — no single node can stop the network from confirming transactions.
