Most reliable free public RPC, correctness incidents across 7 EVM chains
Correctness incidents per 24 hours for free no-key RPC endpoints: block hashes disagreeing with the cross-provider quorum, eth_getLogs counts deviating from the majority, divergent eth_getBalance state and blocked or gated methods, measured continuously alongside consensus head lag.
TL;DR. As of , Lava leads reliability incidents at 7 (24h) on Most reliable free public RPC, correctness incidents across 7 EVM chains. Source: OpenChainBench, https://openchainbench.com/benchmarks/rpc-reliability.
Read this carefully
A zero row means no incident was caught in the window, not a proof of correctness. Most providers post zero most days; this bench exists for the days they do not, and for the errors: a blocked eth_getLogs or a balance read gated behind a paid key at 40 blocks of depth counts as an incident because it is one from the caller's seat.
Bench 010 answers which free public RPC is fastest; this page answers the question that should come first. which one is telling the truth. A fast endpoint that serves a stale head, drops logs from an eth_getLogs response, or answers eth_getBalance from a diverged state view is worse than a slow honest one, and none of that shows up in a latency percentile. So we cross-examine the same keyless provider cohort the latency bench probes, continuously, on three axes. First, consensus head lag: every 60 seconds each provider's reported (height, hash) pair feeds a per-chain quorum map, and the gap between a provider's head and the highest head any provider reported is published as a gauge. Second, hash integrity: when at least two providers agree on the hash at a height, a provider reporting a different hash at that same height is counted, once per height, as a mismatch incident. Third, fixed-vector integrity: every 5 minutes, one chain at a time, every provider gets the identical eth_getLogs query for the chain's canonical USDC contract over a 10-block window behind the tip, plus an eth_getBalance read at the same fixed block; answers are compared across providers and a deviation from the strict majority is an incident. Errors count too, deliberately: 1RPC blocks eth_getLogs outright with a -32000, and PublicNode began gating keyless reads a few dozen blocks deep behind a personal token (-32602) in July 2026. Those are reliability failures a latency bench renders invisible, and here they are the headline.
Methodology
We measure the correctness of free no-key RPC endpoints, not their speed. The harness reuses the bench-010 probe matrix (same providers, same chains, same 60-second header fetch) and adds three metric families. rpc_consensus_lag_blocks tracks each provider's head against the highest head seen across providers for that chain. rpc_hash_mismatch_total counts same-height hash disagreements with the two-or-more-provider quorum, at most once per height, with a strict-plurality rule so a live reorg splitting providers two against two counts nobody. rpc_integrity_check_total classifies fixed-vector checks (eth_getLogs for the chain's canonical USDC over a 10-block window at a daily-rotating depth behind tip, and eth_getBalance of a fixed well-known address at the same block) as ok, error or disagree against the cross-provider majority. The headline is the raw incident count over 24 hours: errors plus disagreements plus hash mismatches. No weighted composite: weights invite gaming disputes, and an incident is an incident.
Frequently asked
What counts as a reliability incident?
Three things, summed over 24 hours from the eu-west probe. An integrity check that errored (method blocked, depth gated behind a key, transport failure). An integrity check whose answer deviated from the strict cross-provider majority (an eth_getLogs count differing from the count at least two other providers agree on, or an eth_getBalance hex that is not byte-identical to the majority answer). And a block-hash mismatch, where the provider reported a hash at a height where at least two providers agreed on a different one. Raw counts, no weights; lower is better and zero is common.
Why do method errors count as incidents when this is a correctness bench?
Because from the caller's seat a method you cannot call is a reliability failure regardless of the reason. 1RPC blocks eth_getLogs with a -32000 error; PublicNode's keyless tier started answering balance reads a few dozen blocks deep with -32602 and a demand for a personal token. Neither returns wrong data, but both break the contract a developer assumes when pasting a no-key URL into a dapp. Counting them alongside genuine disagreements keeps the headline honest: it measures whether the endpoint reliably does what an EVM JSON-RPC endpoint is expected to do.
Can a provider game this benchmark by special-casing the test queries?
The vectors are designed to make that expensive. The eth_getLogs window is anchored at tip minus N where N rotates daily over five depths, so the exact range is never fixed; request ids rotate on every call, defeating body-keyed edge caches; and the USDC contracts are the busiest transfer contracts on each chain, so serving them correctly IS serving real traffic correctly. The head-lag and hash-quorum signals cannot be gamed at all without actually running well-synced nodes, because they are computed from the same latest-header probe the latency bench uses.
Does a reorg unfairly flag providers as mismatching?
No, by construction. During a live reorg two providers can legitimately hold different hashes at the same height. The quorum rule requires a strict plurality: one hash backed by at least two providers and strictly more than any competing hash. A two-against-two split resolves to no quorum and counts nobody, and a mismatch is booked at most once per provider per height. What remains after those guards, a provider outvoted by an established majority at a settled height, is the signal this bench exists to record.
Why is this measured from one region only?
The headline counts incidents from the eu-west vantage because correctness, unlike latency, does not depend on where the client stands: a node serving the canonical chain serves it to everyone. The honest caveat is anycast: each probe sees the serving cluster its region lands on, so a diverged cache serving only another continent is invisible to the eu-west counter. The us-east and Singapore replicas emit the same metric families, and the per-region series are on the chart for cross-checking; the headline stays single-region so the same incident is never double-counted.
Source code github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-capabilities