An Ethereum client is the software that turns a regular computer into a working piece of the Ethereum network. It downloads blocks, checks every transaction against the network’s rules, and keeps a synced copy of the blockchain’s current state. Geth, Nethermind, Erigon, and Besu are all examples — different programs written by different teams, but each one speaking the same protocol.
Most people never install one directly. Wallets, dApps, and exchanges all talk to a client running somewhere else, usually through an API, and that’s the layer most developers actually touch. This guide covers what a client does, why Ethereum runs several competing implementations of it, who actually uses one, and — the part that matters for most readers — how to get access to a client through a provider like NOWNodes instead of running the infrastructure yourself.
What Is an Ethereum Client, Exactly?
An Ethereum client is a program that implements the Ethereum protocol: it connects to peers, downloads and verifies blocks, executes transactions against the current state, and answers requests about that state. Running one is what makes a machine an actual node on the network, rather than just a computer that talks to someone else’s.
Ethereum client: software that implements the Ethereum specification, allowing a computer to join the peer-to-peer network, validate blocks and transactions, and maintain the blockchain’s state. See ethereum.org’s client documentation.
That last part — maintaining state — is what separates a client from a simple network listener. It’s not just watching data pass by; it’s independently recalculating account balances, contract storage, and gas usage after every block, using the exact same rules every other client on the network applies.
Why Does Ethereum Need Client Software at All?
Ethereum has no central server that decides what a valid balance or transaction looks like. Instead, every node runs client software that enforces the rules on its own, and the network only agrees on a shared history because thousands of independently run clients keep reaching the same conclusion.
That redundancy is deliberate, and multiple competing client implementations are part of it. If every node on Ethereum ran identical software, a single bug could take down the entire network at once — which is exactly what nearly happened in 2016, when an attacker exploited a flaw specific to Geth. The network kept running because other clients without that vulnerability stayed online, according to ethereum.org’s own client-diversity page.
So the practical answer is resilience. A bug is contained to whichever share of the network runs that specific software, instead of bringing down Ethereum as a whole — which is also why a serious RPC provider runs more than one client implementation across its infrastructure, rather than betting everything on a single codebase.
Execution Clients vs. Consensus Clients: How the Split Works
Since the Merge in September 2022, running a full Ethereum node actually means running two separate pieces of client software that talk to each other constantly.
An execution client handles everything related to processing transactions: it runs the Ethereum Virtual Machine, executes smart contract calls, manages account state, and serves the JSON-RPC API that wallets and dApps actually call. Geth, Nethermind, Erigon, Besu, and Reth are all execution clients.
A consensus client handles Ethereum’s proof-of-stake layer instead: it tracks the beacon chain, helps produce and confirm new blocks, and decides which chain is the canonical one if the network ever forks. Lighthouse, Prysm, Teku, Nimbus, and Lodestar are consensus clients.
The two communicate over a local connection called the Engine API, a specification maintained jointly by execution and consensus client teams. For almost every practical purpose — reading state, calling a contract, broadcasting a transaction — the execution client is the one your application actually talks to; the consensus client works in the background to keep that data agreed upon across the network.
| Layer | Job | Examples | Talks to your app via |
| Execution client | Runs the EVM, processes transactions, serves RPC | Geth, Nethermind, Erigon, Besu, Reth | JSON-RPC |
| Consensus client | Runs the beacon chain, keeps the network in agreement on the canonical chain | Lighthouse, Prysm, Teku, Nimbus, Lodestar | Not directly — works behind the execution client |
Who Actually Uses Ethereum Clients?
Not everyone touching Ethereum runs a client, and understanding who does — and who just connects to one — explains most of how the ecosystem is actually organized.
- RPC and infrastructure providers run large fleets of clients — including archive nodes — behind an API, so wallets, dApps, and exchanges never have to run their own. NOWNodes is one example, covering Ethereum alongside 120-plus other networks under a single account.
- Block explorers and analytics platforms typically run archive-mode execution clients, since they need full historical state rather than just recent blocks.
- Wallets and exchanges need reliable balance and transaction data behind the scenes, almost always through a provider rather than infrastructure they maintain themselves.
- Developers connect to a client through an RPC endpoint whenever their application needs to read state, call a contract, or send a transaction — the client itself is usually someone else’s problem to run.
That last group is the largest by far. Most people who say “we’re using Geth” actually mean their provider runs Geth behind an endpoint they call — which is exactly the setup the rest of this guide focuses on.
Comparing the Major Execution Clients
Execution client choice affects sync time, disk usage, and which RPC methods are actually available — not just which logo shows up in a dashboard. Here’s how the five most-used clients compare as of 2026.
| Client | Language | Approx. network share | Known for |
| Geth | Go | ~43% | Most widely deployed, broadest wallet/tooling compatibility |
| Nethermind | C#/.NET | ~43% | High transaction throughput, plugin architecture, browser-based node UI |
| Besu | Java | ~8% | Enterprise and consortium deployments, permissioning support |
| Reth | Rust | ~3% | Newer, performance-focused, modular codebase |
| Erigon | Go | ~3% | Storage-efficient archive nodes, staged sync pipeline |
Figures are based on Supermajority.info data cited via clientdiversity.org and shift regularly — treat them as a snapshot, not a fixed ranking.
Geth remains the default most tutorials assume — less for protocol compatibility, since all five implement the same JSON-RPC specification, and more for documentation and tooling support. Nethermind has closed the usage gap largely on throughput: its client documentation reports throughput advantages over Geth and Besu under sustained block-processing load, and it’s the only major client built on .NET rather than Go, Java, or Rust.
Erigon takes a different bet. Its staged-sync architecture and flat key-value storage produce a smaller archive-node footprint than Geth’s Merkle Patricia Trie storage, which is why analytics platforms and indexers reach for it despite its small overall share — archive efficiency matters more to that use case than general adoption.
Not everyone agrees more implementations is automatically safer, either. Robert Leshner, CEO of the crypto asset manager Superstate, argued the opposite case in a 2024 interview: “I think it’s almost safer to have one completely battle-hardened client that everybody is focused on.” His point is that correctly implementing Ethereum’s specification is hard, and every new client is a fresh chance to get an edge case wrong. It’s a real trade-off, and it’s part of why a multi-chain provider typically standardizes on the client with the strongest track record rather than chasing every new implementation.
How to Get Access to an Ethereum Client Through NOWNodes
Running your own execution and consensus client pair is possible, but it means provisioning real hardware, keeping both pieces of software updated through every hard fork, and resyncing when something breaks. Most developers skip that entirely and connect to a client someone else already runs — this is what an RPC provider like NOWNodes actually offers.
The setup takes four steps:
- Create a NOWNodes account and generate an API key from the dashboard.
- Grab the Ethereum endpoint URL for the interface you need — standard RPC, WebSocket, or Blockbook, depending on the network.
- Point your application at that endpoint in place of a local node address, using your API key for authentication.
- Send a request. Standard methods like eth_getBalance, eth_call, and eth_sendRawTransaction work exactly as they would against a self-hosted client, since JSON-RPC is standardized across every implementation and every provider.
That’s the whole difference between running a client and using one: the endpoint replaces the hardware, and the API key replaces the sync process.
Choosing Shared, Dedicated, or Free Access
NOWNodes’ shared nodes cover Ethereum RPC access on infrastructure used by multiple customers at once — a practical starting point for development and moderate production traffic without managing any client software directly.
For higher or more predictable throughput, dedicated nodes give one customer an isolated instance with no shared-tier request ceiling, and — this is the detail that actually ties back to client choice — customers can select which execution client backs their dedicated node, including Geth or Erigon. That matters if a project depends on client-specific behavior, like Erigon’s more efficient archive queries or a particular Trace method.
Teams that just want to try things out can start on free public endpoints with no signup required, though those are capped at 5 requests per second and aren’t built for production load.
Interfaces Beyond Basic RPC
Standard JSON-RPC covers balance checks, contract calls, and transaction broadcasting, but it isn’t the only way to pull data from an Ethereum client through NOWNodes. WebSocket access keeps a persistent connection open for live updates instead of repeatedly polling, which suits wallets and monitoring tools that need to react the moment something changes on-chain.
Archive access and Debug/Trace methods are also available on supported Ethereum endpoints, letting a team query old historical state or step through a transaction’s internal execution — the same depth you’d get running Erigon or Geth in archive mode yourself, without provisioning the multi-terabyte disk that mode actually requires.
Conclusion
An Ethereum client is the software doing the actual work of validating the network, split since the Merge between an execution client that processes transactions and a consensus client that keeps the network in agreement. Which implementation runs underneath — Geth, Nethermind, Erigon — mostly affects sync time, disk usage, and which advanced methods are available, since JSON-RPC keeps the interface standardized across all of them.
For most teams, the practical question isn’t which client to run — it’s whether to run one at all. Connecting to Ethereum through NOWNodes means an authenticated endpoint that’s already synced, with the option to pick the underlying client on a dedicated node when a project genuinely needs it, instead of the hardware and upgrade maintenance that self-hosting requires.
FAQ
Do I Need to Choose a Specific Client If I Use an RPC Provider?
Usually no — most providers abstract this away, and your application only sees standard JSON-RPC responses regardless of which client answers the request. NOWNodes lets you pick the underlying execution client — Geth or Erigon — specifically on its dedicated-node tier, when a feature or trace method depends on it.
Which Ethereum Client Is Fastest to Sync?
Sync speed depends more on sync mode than client brand — Geth’s snap sync and Erigon’s staged sync are both designed to cut initial sync from days to hours on capable hardware. Erigon generally holds an edge for full archive syncs specifically, due to its more storage-efficient design.
What’s the Difference Between a Shared and a Dedicated Ethereum Node?
A shared node runs on infrastructure used by multiple customers at once, governed by plan-based request limits — the standard setup for development and moderate traffic. A dedicated node is isolated to one customer, with no shared-tier request ceiling and the ability to configure details like the underlying execution client.
Is a Free Public Ethereum Endpoint Safe to Use in Production?
Free public endpoints are useful for prototyping but typically cap out at a few requests per second — NOWNodes’ public tier is limited to 5 RPS — and aren’t intended as production infrastructure. Move to an authenticated shared or dedicated plan once your application handles real traffic.
Can I Switch Which Ethereum Client Backs My RPC Access Later?
Yes, in most cases. Because JSON-RPC is standardized, switching the underlying client — or switching providers entirely — is typically a matter of updating an endpoint or configuration setting rather than rewriting application logic, though a project relying on a client-specific method should confirm it’s still supported first.
