A public Ethereum node is a node someone else runs and opens to the internet, so you can read the chain or broadcast a transaction without operating your own hardware. Most are free, shared, and capped by a rate limit.
For a wallet demo, a hackathon, or a quick script, that trade is usually worth it. For anything carrying real traffic or real money, the same endpoints start to crack — throttling, downtime, missing historical data.
This guide covers what these endpoints are, what the alternative actually costs in 2026, which free public Ethereum nodes are worth using, and the point where a managed endpoint makes more sense.
What Is a Public Ethereum Node?
A public Ethereum node is a full node that a provider keeps synced and exposes through a JSON-RPC interface that anyone can call. You send a request to a URL, and the node answers with data straight from the network. No account, no key, in most cases no cost.
JSON-RPC is the standard protocol Ethereum clients use to talk to applications — wallets, explorers, and dApps all speak it (Ethereum’s JSON-RPC documentation lists the full method set). A single call looks like this:
json
{ "jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1 }Point that request at a public endpoint and you get back the latest block height. Swap the method for eth_getBalance, eth_call, or eth_sendRawTransaction and you can read balances, query contracts, or push a signed transaction. Every endpoint in this guide answers for the same network: Ethereum mainnet.
Why Developers Use Shared Endpoints Instead of Running a Node
The short answer: running your own Ethereum node is a standing commitment, not a one-off install. You pair an execution client with a consensus client and keep both online, synced, and updated around the clock (ethereum.org’s node guide).
A public endpoint hands that whole job to someone else. You skip the hardware, the sync wait, and the maintenance, and get a working connection in a single line of code.
What Does Running an Ethereum Node Actually Require?
A full node needs a fast disk above everything else. Ethereum’s state is a random-read workload, so the baseline is a 2 TB NVMe SSD — a SATA drive struggles, and a hard drive never finishes syncing. Current hardware guidance for operators is tracked in EIP-7870.
| Component | Minimum | Recommended |
|---|---|---|
| Disk | 2 TB NVMe SSD | 4 TB NVMe SSD |
| RAM | 16 GB | 32 GB |
| CPU | 2–4 cores | 4–8 cores |
| Network | Unmetered broadband | Gigabit, unmetered |
| Initial sync | ~1–2 days on a fast disk | — |
None of those numbers is extreme on its own. The catch is that they apply continuously. The chain keeps growing, clients need patching, and a missed upgrade can leave your node stuck on the wrong fork. For most projects, that upkeep is the reason to use a hosted endpoint instead.
Who Should Use a Public Endpoint — and Who Shouldn’t
Public endpoints fit anything low-stakes and read-heavy. They make a poor base for anything that has to stay up or stay private.
Good fits:
- Learning, tutorials, and local testing
- Hackathons and throwaway prototypes
- Wallet setup and occasional manual queries
- A backup endpoint sitting behind your primary provider
Weaker fits:
- Production dApps with real users
- High-frequency reads, indexing, or analytics
- Workloads that need archive history or trace and debug methods
- Anything where a third party seeing your queries is a problem
Which Free Public Endpoints Are Worth Using in 2026?
These are the shared endpoints developers reach for most often. All are free, all are rate-limited, and none publish a production SLA — treat the limits below as “enough to build with,” not “enough to launch on.”
| Provider | Mainnet endpoint | WebSocket | Signup / key | Notes |
|---|---|---|---|---|
| PublicNode (Allnodes) | https://ethereum-rpc.publicnode.com | Yes | None | Privacy-first; publishes live node stats |
| Ankr | https://rpc.ankr.com/eth | Limited | None for public tier | Global routing; higher limits need a key |
| 1RPC | https://1rpc.io/eth | No (public tier) | None | Privacy relay that strips request metadata |
| dRPC | https://eth.drpc.org | Yes | None for public tier | Aggregates several upstream providers |
| BlockPI | https://ethereum.blockpi.network/v1/rpc/public | Yes | None for public tier | Distributed nodes; free tier throttled |
They overlap more than they differ. PublicNode and dRPC are the easy defaults for a quick connection with WebSocket support. 1RPC is the pick when you care about not leaking your IP and request pattern to the node operator. Ankr and BlockPI both gate their better limits behind a free account, so the plain “public” URL is the slowest tier they offer.
What Is ethereum-rpc.publicnode.com?
It is the free Ethereum mainnet endpoint run by Allnodes under its PublicNode brand. You can call it over HTTPS at https://ethereum-rpc.publicnode.com or open a WebSocket at wss://ethereum-rpc.publicnode.com, with no signup and no key.
PublicNode routes requests across Allnodes’ own infrastructure, markets itself as privacy-first, and publishes live request and node statistics on its site. Like every endpoint here, it is rate-limited and meant for development and light use rather than production load.
How Do You Connect to a Public Endpoint?
Connecting takes three steps plus a fallback. Pick a URL, point your code at it, and confirm you are on the right network.
- Choose an endpoint from the table above and copy its URL.
- Point your library or wallet at it. In ethers.js that is one line:
js
import { JsonRpcProvider } from "ethers";
const provider = new JsonRpcProvider("https://ethereum-rpc.publicnode.com");
const block = await provider.getBlockNumber();- Confirm the returned chain ID is 1 (mainnet), then add a second endpoint as a fallback so a single outage does not take you offline.
A few habits keep public endpoints from biting you:
- Keep endpoint URLs in environment variables, not hardcoded in source.
- Configure at least one backup endpoint and fail over automatically.
- Watch for HTTP 429 and “rate limit” errors, and back off when you see them.
- Only use endpoints from providers you can name. A random URL can quietly feed you tampered data.
When Should You Move Beyond Public Endpoints?
Switch when the free tier becomes the bottleneck: constant 429s, an endpoint that drops at peak, missing archive history, or queries you would rather not route through a shared node.
A managed provider closes those gaps. NOWNodes, for example, publishes free public endpoints capped at 5 requests per second with no API key — the same role as the endpoints above, useful for testing. When a project outgrows that, the same Ethereum node is available on shared plans with a key and higher quotas, or as a dedicated node with no predefined rate limit, archive access, trace and debug methods, and IP whitelisting.
The decision is not public versus managed forever. Most teams start on public endpoints, keep one as a fallback, and move their main traffic to a keyed or dedicated endpoint once uptime and throughput start to matter.
Conclusion
Public Ethereum nodes are the fastest way onto the network and the right tool for learning, prototyping, and testing. They are also shared and rate-limited by design, with no promise they will be up when you need them.
Use them freely while the stakes are low. Keep a fallback configured, verify every URL, and watch your error rate. When throttling, downtime, or missing historical data starts breaking things, that is the signal to move your core traffic to a keyed or dedicated endpoint — and to keep a public one in reserve.
FAQ
What is chain ID 1 on Ethereum?
Chain ID 1 is the identifier for Ethereum mainnet. Wallets and libraries use it to confirm they are signing transactions for the real network rather than a testnet or another EVM chain, which stops a signed transaction from being replayed where it does not belong.
Do free public Ethereum nodes support WebSocket connections?
Some do. PublicNode, dRPC, and BlockPI expose WebSocket URLs for subscriptions such as new blocks or pending transactions, while others offer HTTPS only. If you need live push updates instead of polling, check for a wss:// endpoint before committing.
Can I send transactions through a public endpoint?
Yes. You sign the transaction locally and submit the signed payload with eth_sendRawTransaction; the public node only relays it. Your private key never leaves your machine, so broadcasting through a shared endpoint does not expose it — though the operator can still see the transaction you sent.
Do public endpoints keep logs of my requests?
It depends on the operator, and most do not spell it out. Some, like 1RPC and PublicNode, market themselves as privacy-first and minimize what they retain. If your queries reveal sensitive information — the addresses you are watching, for instance — route them through an endpoint you control or a privacy-focused provider.
How do I know a public endpoint runs the latest Ethereum upgrade?
A maintained endpoint follows mainnet automatically, so it should already reflect recent hard forks such as Pectra and Fusaka, both of which shipped in 2025 (Ethereum Foundation blog). If a provider’s node is stale, calls that rely on new behavior can fail or return outdated data — a quick eth_blockNumber checked against a block explorer shows whether it is current.
