Fastest public RPC provider
HTTP round-trip latency for eth_blockNumber against free, no-key public RPC endpoints, audited every 15 seconds.
This benchmark answers the question every developer reaching for a free public RPC asks before pasting a URL into their dapp. which no-key endpoint is actually fast and reliable right now, on the chain my product runs on. Alchemy and Infura own the keyed-tier market; the free public side of the question lives elsewhere, in the RPC services dapps hit when a contributor's free quota is the budget. We probe `eth_blockNumber` every 15 seconds against 15 audited providers across 10 EVM chains. PublicNode, dRPC, 1RPC, MeowRPC, Tenderly Gateway, Nodies (POKT), Lava Network, Merkle, Flashbots Protect, Cloudflare and the chain-official endpoints (Coinbase's `mainnet.base.org`, Binance's `bsc-dataseed1`, Ava Labs' `api.avax.network`, Arbitrum Foundation's `arb1.arbitrum.io`, Optimism Foundation's `mainnet.optimism.io`). Chains covered. Ethereum (9 providers), Arbitrum (8), Base (6), Optimism (6), Avalanche (6), BNB (5), Polygon (5), Linea + Scroll + Mantle (4 each). Use the chain tab above to filter the leaderboard. Latency is the headline number; the leaderboard also exposes call-result classification (`ok` vs `http_err` vs `jsonrpc_err` vs `stale` vs `timeout`, the Cloudflare-eth trap where a 200 OK hides a JSON-RPC error field) and archive-depth support so a fast endpoint that returned a state-pruned response at block (head, 5M) is not silently treated as a viable archive source.
Methodology
We measure the round-trip latency of a single, identical RPC call (`eth_blockNumber`) against every major no-key Ethereum-compatible public RPC endpoint, on Ethereum mainnet, Base and BNB Chain. The harness emits three metric families from one binary because they share the same (provider × chain) client matrix and same 15 s scrape interval: (a) `rpc_latency_milliseconds` for the speed leaderboard, (b) `rpc_call_total{result}` for the reliability and silent-failure analysis, (c) `rpc_archive_depth_supported{depth}` for an honest read on which endpoints actually serve historical state. The depth set covers Geth's default pruned cap (~5760 blocks) up through genesis-era archive (5M blocks). Stale-head detection compares each provider's reported block against the cross-provider tip and flags anything more than 20 blocks behind so a dead endpoint stuck on an old number is not silently ranked as the fastest.
Frequently asked
What is the fastest free public RPC right now?
Cloudflare currently leads the active chain tab at 7 ms (p50, 24 h) across 15 measured providers. The leaderboard re-sorts every 15 seconds against fresh Prometheus samples, so the answer reflects the last 24 hours of measured `eth_blockNumber` round-trip latency from eu-west, not a marketing-page claim. Switch the chain tab (10 EVM chains: Ethereum, Polygon, Arbitrum, Optimism, Base, BNB, Avalanche, Linea, Scroll, Mantle, or All) to see the leader on the network your product runs on.
Which public RPCs work without an API key in 2026?
15 audited providers across 10 EVM chains. Universal multi-chain (work on 4+ chains): PublicNode, dRPC, 1RPC, Tenderly Gateway (`gateway.tenderly.co/public/<slug>`), Nodies (POKT successor at `*-pokt.nodies.app`). Ethereum-specific or limited footprint: MeowRPC (ETH + Arbitrum only since 2025), Flashbots Protect, Cloudflare (read-degraded), Lava Network (ETH + Arbitrum no-key, other chains require key), Merkle (Base + BSC stable, ETH locked-out by Cloudflare). Chain-official foundation RPCs: Arbitrum (`arb1.arbitrum.io/rpc`), Optimism (`mainnet.optimism.io`), Base (`mainnet.base.org`), Avalanche (`api.avax.network`), BNB (`bsc-dataseed1.binance.org`). Excluded: Ankr (key-gated), gateway.fm (29 req/IP), LlamaRPC / BlockPI / OmniaTech (Cloudflare 521 region-blocked), Alchemy demo (rate-limited dead), NodeReal / GetBlock / Chainstack (key-gated).
Why is Cloudflare-eth returning errors?
Cloudflare's public Ethereum gateway recently switched to a permissioned mode for many JSON-RPC methods. The endpoint still returns HTTP 200 quickly, but the body is increasingly a JSON-RPC error (`-32046 Cannot fulfill request`) rather than a block number. This benchmark catches the trap by classifying responses as `ok` only when both the HTTP status is 200 and the JSON-RPC body has a usable `result` field. Latency without reliability is a misleading ranking signal for a public RPC.
Which free RPC supports Ethereum archive node calls?
Most free public RPCs are state-pruned, so `eth_getBalance` at block (head, 5,000,000) returns an error rather than the historical balance. This benchmark probes five depths (300, 7,200, 216,000, 1,296,000, 5,000,000 blocks) every five minutes and exposes a gauge per provider per depth. The page surfaces a per-provider archive-depth badge: a green tick at the 5M tier means full historical state is available for free without a key. Anything pruned at 7200 confirms the endpoint is on a Geth default config and only serves the last ~24 hours.
How is RPC latency measured on OpenChainBench?
The harness issues a single `eth_blockNumber` JSON-RPC POST every 15 seconds against each (provider, chain) pair from eu-west, using the same plain HTTP client for every endpoint. Wall-clock delta around the round-trip is recorded with millisecond precision and pushed to both a gauge and a histogram. p50/p90/p99 are computed via Prometheus `quantile_over_time` over the last 24 hours. Stale-head detection compares each response against the cross-provider tip and flags anything more than 20 blocks behind as `stale`, so a dead endpoint stuck on yesterday's block cannot rank as the fastest.
Are public RPCs production-grade for a dapp?
Read the success-rate column before deciding. A median latency under 100 ms is irrelevant if the endpoint silently returns a JSON-RPC error 5% of the time or stalls during an L1 reorg. Free public RPCs share rate-limit budgets with the entire internet and have no SLA. They are good for read-heavy demos, local development and fallback paths; production dapps usually graduate to a keyed tier (Alchemy, QuickNode, Infura) for `eth_sendRawTransaction`, websocket subscriptions and archive queries beyond Geth's pruned cap. This benchmark measures the no-key tier specifically because that is the unmeasured part of the market.
Source code github.com/OpenChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities
