Fastest Base WebSocket newHeads push, live block-push lag across RPC providers
Per-block WebSocket push lag in milliseconds versus the earliest provider to deliver the same Base head, measured continuously from one eu-west vantage point.
TL;DR. As of , PublicNode leads block push lag at 0.4 ms (p50, 24h) on Fastest Base WebSocket newHeads push, live block-push lag across RPC providers. Source: OpenChainBench, https://openchainbench.com/benchmarks/ws-head-latency-base.
Base blocks land every 2 seconds, six times more frequently than Ethereum, and any real-time bot on Base (perp keeper, MEV searcher, live dashboard) inherits its provider's head push pipeline six times as often. This page ranks the free keyless Base WebSocket endpoints by the same relative race the Ethereum sibling uses: earliest provider to deliver block N sets T0, every other provider's sample is arrival minus T0. The harness holds one persistent `eth_subscribe("newHeads")` connection per provider from an eu-west host and timestamps every frame on receipt. Sample volume on Base is substantially higher than Ethereum thanks to the faster cadence, so the leaderboard reflects a rich distribution rather than a handful of tail observations. Provider cohort at launch: PublicNode and dRPC keyless endpoints. Tenderly does not expose a keyless Base WebSocket path at the time of ship.
Methodology
Per-chain member of the WebSocket head-latency cluster, applied to Base. Same harness, same race scoring rules, same reporting cadence: one persistent WebSocket per provider from the same eu-west host, cohort settle window 5 seconds after the first arrival, lag histogram per provider, gap counter for missed blocks inside a live subscription. The cross-chain view lives on the parent [ws-head-latency](https://openchainbench.com/benchmarks/ws-head-latency-ethereum) benchmark; this page is the Base-scoped answer.
Frequently asked
What is the fastest free Base RPC over WebSocket right now?
PublicNode currently wins most per-block races on Base with a median lag of 0.4 ms versus the earliest arrival (p50, 24 h) across 2 measured keyless providers. The leaderboard re-scores on every Base block, roughly every 2 seconds, so the answer reflects sustained live measurement, not a one-off test. Check the win rate and the trailers' p99 before wiring a latency-sensitive Base bot to any single provider.
How is Base WebSocket head lag measured on OpenChainBench?
One Go harness holds a persistent `eth_subscribe("newHeads")` WebSocket per provider from the same eu-west host. Every frame is timestamped on receipt at millisecond precision. Each block is scored as a race: earliest arrival sets T0 and every other provider's lag is arrival minus T0. The cohort closes 5 seconds after the first arrival, then p50/p90/p99 are computed via `histogram_quantile` over 24 hours.
Why does the fastest provider read near zero?
By construction. The measurement is relative to the fastest arrival in the cohort, not to an external reference clock, so the provider that wins most races accumulates mostly zero samples. This is deliberate: without a reference node co-located with the Base sequencer, a single vantage point cannot separate its own network latency from the provider's push pipeline. Read the leader's win rate and the trailers' distributions rather than the leader's absolute number.
Why isn't Tenderly ranked on Base?
Tenderly's public Base gateway does not expose a keyless WebSocket path for `eth_subscribe("newHeads")` at the time this bench went live. When it does, the harness reads the endpoint from an env variable and Tenderly joins the leaderboard automatically.
Base blocks land every 2 seconds. How does that change the numbers?
Sample volume is roughly 6 times higher than Ethereum for the same 24h window. That tightens the confidence interval on every percentile: a 24h p50 on Base is drawn from ~43000 samples per provider versus ~7200 on Ethereum. The percentile numbers themselves are still relative to the per-block winner, so the interpretation is unchanged; the Base leaderboard just carries less tail noise than the Ethereum one.
Source code github.com/ChainBench/OpenChainBench/tree/main/harnesses/ws-head-latency