RPCsUpdated

Fastest private Ethereum WebSocket push, per-block race across keyed RPC providers

Per-block WebSocket push lag in milliseconds versus the first provider to deliver the same Ethereum block, across API-key endpoints probed from us-east, eu-west and Singapore.

TL;DR. As of , GetBlock has the lowest median lag behind the first Ethereum block push, inside the first histogram bucket; Quicknode trails at 73 ms (p50, 24h) across 4 ranked providers. Source: OpenChainBench, https://openchainbench.com/benchmarks/ethereum-rpc-ws.

A bot that subscribes to eth_subscribe(newHeads) does not care what a provider's median HTTP latency is. It cares who hands it block N first, and by how much the others trail. This page races the private (Ethereum) cohort: one WebSocket per provider per region, open ten minutes in every hour across the whole cohort, every frame timestamped on arrival, each block scored against whichever provider delivered it earliest. GetBlock currently leads, first on 69% of the blocks it received (24h), across 4 keyed providers.

Because the measurement is relative, the leader reads near zero by construction. The numbers to read are the gap to the runner-up and the shape of the trailing distribution, p50 against p99, not the leader's absolute figure.

Methodology

Private, API-key Ethereum endpoints raced on WebSocket delivery. One harness holds an eth_subscribe(newHeads) subscription per provider in each of three regions and timestamps every push on receipt. Per block, the earliest arrival across providers in that region defines T0; each provider's sample is its own arrival minus T0, in milliseconds. The same process runs the HTTP arm of the keyed cohort, which is deliberate: comparing arrival times recorded by separate processes would compare clocks as much as providers, and the differences here are tens of milliseconds.

  • Race, not latency: all providers on a chain wait for the same block, so only the spread between them belongs to them. Time from block production to first arrival is the chain's block time and is not published as a provider result.
  • One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
  • Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
  • Histogram buckets floor at 0.5 ms. The winner reads 0 by construction, so a coarse first bucket collapses every leader's p50 into an interpolation artifact inside it.
  • Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its median says.
  • GetBlock issues one WebSocket token per chain per region, so its three cells are distinct endpoints rather than one URL probed from three places.
  • Alchemy is measured on the HTTP cohort but not here, and the reason is ours rather than theirs: its endpoint bills WebSocket per message, these subscriptions pushed about 116 million frames a month against the Free plan key that row discloses, and the key is shared with the HTTP probes. Racing a provider until its account is exhausted would remove it from nine other pages, so it waits for a message budget guard.
  • Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
  • Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

Results: 4 providers ranked by Push lag (p50, 24h)

Fastest private Ethereum WebSocket push, per-block race across keyed RPC providers: Push lag per provider (p50, 24h).
№Providersp50p90p99First to pushSuccess
1GetBlockPrivate WS, same keyed endpoint as the HTTP cohortfirst · 69%134 ms349 ms69.3%100.00% (n=3592)
2QuicknodePrivate WS, same keyed endpoint as the HTTP cohort73 ms209 ms1.49 s28.7%100.00% (n=3592)
3ChainstackPrivate WS, same keyed endpoint as the HTTP cohort120 ms247 ms4.26 s1.92%100.00% (n=3592)
4DwellirPrivate WS, same keyed endpoint as the HTTP cohort1.10 s1.69 s3.71 s0%99.97% (n=3591)

Frequently asked

Which private RPC provider pushes new Ethereum blocks first over WebSocket?

GetBlock has the lowest median lag behind the first arrival over 24h; a figure inside the first histogram bucket reads as zero. Dwellir trails most, at 1.10 s (p50, 24h). The board re-scores on every Ethereum block. Read the p99 column before wiring a latency-sensitive bot to one provider.

Why does the fastest provider show a lag near zero?

By construction. Each block is a race: the earliest arrival defines T0 and every sample is measured against it, so the provider that wins most races accumulates mostly zero samples. A single vantage point cannot measure absolute production-to-client latency without a node co-located with block producers; it can measure fairly which provider delivers the same block earlier over the same path. Read the gap to the runner-up and the trailing distribution, not the leader's absolute number.

Is this the same as the HTTP latency cohort on this chain?

Same providers, same keys, same regions, different question. The HTTP cohort measures a request you send; this measures a push you wait for, and the two orderings are not the same. GetBlock issues one WebSocket token per chain per region, so its three cells are distinct endpoints rather than one URL probed from three places.

Could a provider win by pushing blocks before validating them?

In principle, at the cost of occasionally pushing something that gets retracted. That is why coverage is published next to the lag: a provider that pushes early but wrong shows gaps, and the coverage column counts blocks seen against the cohort maximum. Hash-level cross-checking against an independent reference is not in this version.

Source code github.com/ChainBench/OpenChainBench/tree/main/harnesses/rpc-keyed-latency