BlockchainsUpdated

Fastest L2 block time, live across Robinhood, Arbitrum, Base and 6 more

Wall-clock interval in milliseconds between two consecutive newHeads events on each L2 sequencer, refreshed continuously.

TL;DR. As of , Robinhood Chain posts the lowest block time at 92 ms (p50, 24h) across 9 ranked chains. Source: OpenChainBench, https://openchainbench.com/benchmarks/l2-block-time.

This benchmark measures the live block time of every major Ethereum Layer 2, the actual wall-clock interval between two consecutive newHeads events on the sequencer, not the marketing figure each chain advertises. Arbitrum One leads with sub-second blocks (~250 ms median), built on Nitro's fast-finality fork. Optimism, Base and Mantle all cluster around the 2 s OP Stack default. zkSync Era, Linea and Scroll show batched cadence with p50 around 3-6 s and a long tail on idle gaps. Taiko's based rollup sits at the 3 s mark. The p99 column reveals stalls 2-3× the nominal block time on every L2, the part marketing pages never quote.

Methodology

We measure the live block time of every major Ethereum L2 by holding a persistent WebSocket subscription to `eth_subscribe("newHeads")` on each sequencer. The harness records T1 when block N arrives and T2 when block N+1 arrives; the sample is wall-clock T2 − T1 in milliseconds. p50 / p90 / p99 are computed via Prometheus `quantile_over_time` over the 24 h window. The histogram bucket boundaries (50 ms → 60 s) cover the full range from Arbitrum's sub-second cadence to zk-rollup batching gaps. Disconnects reconnect with exponential backoff and the natural outlier sample is capped at 5 min so a reconnect can't pollute p50.

  • Robinhood Chain exception: the sequencer exposes no public WebSocket, so its block time is derived from eth_blockNumber deltas polled every 2 seconds over HTTP. A window that advanced N blocks contributes N samples of (elapsed / N) ms, which preserves per-block weighting and yields an accurate average; per-block jitter is not captured on this chain and this note is the disclosure.
  • Cadence: continuous WebSocket subscription per L2, one persistent connection, no polling.
  • Subscribe payload: `{"jsonrpc":"2.0","id":1,"method":"eth_subscribe","params":["newHeads"]}`. No API key, public endpoints (publicnode.com mostly, era.zksync.io/ws for zkSync).
  • Sample: block-time(N) = T_recv(N) − T_recv(N-1), measured in milliseconds with `time.Now()` precision on the harness clock. Block-number duplicates from the same connection are filtered.
  • Sanity bound: any single sample > 5 min is dropped (reconnect artifact, never a real block-time).
  • Reconnect logic: exponential backoff 2 s → 60 s on dial / read errors. Per-chain `l2_block_time_reconnects_total` counter exposed for instability alerting.
  • Endpoint health: client-side ping every 30 s defensive against idle close, pong handler resets the read deadline. publicnode and era.zksync.io endpoints verified live for 90-second windows during harness inception (full table in the harness README).
  • Excluded by design: Polygon zkEVM and Mode (no public no-key WS available, would require an API-keyed contributor endpoint; deferred to v2). Starknet excluded, Cairo stack with a different RPC shape, would live in its own bench.

Results: 9 chains ranked by Block time (p50, 24h)

Fastest L2 block time, live across Robinhood, Arbitrum, Base and 6 more: Block time per chain (p50, 24h).
№Chainsp50p90p99Success
1Robinhood ChainArbitrum Orbit, ~100ms blocks, HTTP-polled (no public WSS)92 ms175 ms198 ms100.00% (n=830797)
2BaseOP Stack, 2 s sequencer194 ms436 ms494 ms99.58% (n=429765)
3Arbitrum OneNitro fast-finality, sub-second sequencer335 ms479 ms891 ms99.58% (n=310810)
4ScrollzkEVM rollup, prover-bound cadence1.58 s17.13 s52.76 s99.10% (n=14915)
5zkSync Erazk-rollup, batched producer1.73 s14.78 s46.31 s99.86% (n=17585)
6MantleOP Stack fork, modular DA, 2 s sequencer1.88 s2.77 s2.98 s99.58% (n=42930)
7OptimismOP Stack default, 2 s sequencer1.94 s2.79 s2.98 s99.58% (n=42928)
8TaikoBased rollup, L1-sequenced by Ethereum validators1.99 s2.81 s3.00 s99.72% (n=43042)
9Lineazk-rollup, prover-bound cadence4.85 s17.26 s48.71 s99.79% (n=10755)

Block time by chain

Live p50 over the last 24 hours per chain, ranked lowest first. Each chain has its own consensus mechanism. The explainer below matches what the harness actually measures.

Robinhood Chain block time

92 ms p50, 24h · Arbitrum Orbit, ~100ms blocks, HTTP-polled (no public WSS).

Robinhood Chain block time is 92 ms (p50, 24h), the most aggressive cadence in the cohort: the Arbitrum Orbit stack lets Robinhood's sequencer target ~100 ms blocks for tokenized-stock settlement. The chain launched mainnet on July 1, 2026, pays gas in ETH and settles to Ethereum blobs. Measurement note: Robinhood exposes no public WebSocket, so block time here is derived from block-number deltas over 2-second HTTP poll windows, an accurate average that does not capture per-block jitter.

Base block time

194 ms p50, 24h · OP Stack, 2 s sequencer.

Base block time is 194 ms (p50, 24h). Base is operated by Coinbase on the OP Stack and inherits its 2 second sequencer cadence; Coinbase has publicly tested a Flashblocks pre-confirmation path at 200 ms but the canonical `newHeads` stream still emits one block every 2 s. Settlement posts to Ethereum via EIP-4844 blobs. Measured live by subscribing to `newHeads` on the public Base sequencer WebSocket and computing T(N+1) minus T(N) in milliseconds.

Arbitrum One block time

335 ms p50, 24h · Nitro fast-finality, sub-second sequencer.

Arbitrum One block time is 335 ms (p50, 24h). Arbitrum Nitro defaults to a 250 ms sequencer interval, by far the most aggressive cadence in the L2 cohort, made possible because the Nitro stack decouples block production from L1 anchoring and runs a single Offchain Labs sequencer that posts batches to Ethereum asynchronously. Measured by holding an `eth_subscribe("newHeads")` WebSocket on the public Arbitrum RPC and recording wall-clock deltas between consecutive head events.

Scroll block time

1.58 s p50, 24h · zkEVM rollup, prover-bound cadence.

Scroll block time is 1.58 s (p50, 24h). Scroll is a bytecode-equivalent zkEVM running a centralized sequencer that batches transactions for a Halo2-based prover; the nominal block target is 3 s but the practical floor is driven by the prover-batch cadence, identical in shape to Linea and zkSync, with a long idle tail when traffic is sparse. Measured via the public Scroll WebSocket and `newHeads` deltas.

zkSync Era block time

1.73 s p50, 24h · zk-rollup, batched producer.

zkSync Era block time is 1.73 s (p50, 24h). zkSync Era is a zk-rollup with a Matter Labs-operated sequencer; block production is batched because the prover must generate a SNARK before the batch is finalized on Ethereum, so within a busy burst blocks land near 1 s but the median drifts up during quiet periods when the sequencer waits to fill a batch. Measured via the `era.zksync.io/ws` WebSocket and `newHeads` inter-arrival deltas.

Mantle block time

1.88 s p50, 24h · OP Stack fork, modular DA, 2 s sequencer.

Mantle block time is 1.88 s (p50, 24h). Mantle is an OP Stack fork with a Mantle Foundation sequencer at the OP Stack 2 s default, but it swaps Ethereum calldata for EigenDA as the data-availability layer, which decouples DA cost from L1 blob price without changing the L2 block cadence the user sees. Measured via `newHeads` inter-arrival on the public Mantle sequencer WebSocket.

Optimism block time

1.94 s p50, 24h · OP Stack default, 2 s sequencer.

Optimism block time is 1.94 s (p50, 24h). The OP Stack ships with a hard-coded 2 second sequencer interval, which is what the Optimism Foundation sequencer commits to; the L2 only produces a new block when that timer fires, even on empty traffic. Settlement is on Ethereum via blob calldata after Dencun. Measured by holding a persistent `newHeads` WebSocket against the public Optimism sequencer RPC and reporting the inter-arrival delta.

Taiko block time

1.99 s p50, 24h · Based rollup, L1-sequenced by Ethereum validators.

Taiko block time is 1.99 s (p50, 24h). Taiko is a based rollup: there is no centralized sequencer; Ethereum L1 validators sequence Taiko blocks directly by including L2 proposals in L1 blocks, which means Taiko's effective slot is bounded below by Ethereum's 12 s slot. The architecture trades raw L2 cadence for inheriting Ethereum's liveness and censorship-resistance. Measured via `newHeads` on the public Taiko WebSocket.

Linea block time

4.85 s p50, 24h · zk-rollup, prover-bound cadence.

Linea block time is 4.85 s (p50, 24h). Linea is a Consensys-operated zkEVM with a single sequencer feeding a prover that produces PLONK-family proofs posted to Ethereum; the documented target is a 2 s slot but observed cadence is governed by prover throughput, so idle windows stretch into multi-second gaps that lift the median above the nominal slot time. Measured by holding `newHeads` on the public Linea RPC.

Frequently asked

What is the fastest Layer 2 block time?

Arbitrum One leads the leaderboard at sub-second block times, typically 200-300 ms median, occasionally spiking past 800 ms under load. Arbitrum Nitro's fast-finality fork is the reason: it commits blocks every 250 ms by default, far below the 2 s convention used by most OP Stack chains.

Why are Base and Optimism block times so similar?

Base and Optimism both run the OP Stack with the same default sequencer cadence (2 s). Mantle is also an OP Stack fork, and its block time clusters identically. The architectural similarity is by design: OP Stack is meant to be a turnkey rollup framework where the sequencer interval is a configuration constant, not a chain-specific design choice.

What is the block time on zkSync Era, Linea, and Scroll?

zk rollups produce blocks in bursts rather than at a fixed cadence. p50 sits around 3-6 s but p90 / p99 can balloon to 15-30 s during idle periods because the sequencer waits for enough transactions to fill a batch before generating the validity proof. The nominal '2 s block time' those chains advertise is the within-burst figure, not the median observed externally.

Is L2 block time the same as L2 finality?

No. Block time measures how often the sequencer produces a block, it's a soft confirmation, reversible if the sequencer decides to. Finality on an L2 means the L1 anchor batch is final on Ethereum, which takes 12-18 minutes (block posting + 12.8 min Casper finality) at best, and 7 days for optimistic rollups under contestation. We track the latter in a separate bench.

How is the L2 block time measured here?

We hold one persistent WebSocket subscription per L2 via `eth_subscribe('newHeads')`. Every new head event is timestamped on receipt and the difference between consecutive events is the block-time sample. p50 / p90 / p99 are computed via Prometheus `quantile_over_time` over the last 24 h. Reconnect artifacts above 5 min are filtered so a network blip can't skew the percentiles.

What about Polygon zkEVM, Mode, Starknet and the rest?

Polygon zkEVM and Mode don't expose a public WebSocket endpoint without an API key, so we defer them to v2 when an API-keyed contributor endpoint lands. Starknet uses the Cairo stack with a different RPC shape, it would live in a dedicated bench rather than be shoehorned into the EVM cohort here. Berachain, Sonic and other adjacent chains are L1s, not L2s, so they live in the l1-finality bench.

Source code github.com/ChainBench/OpenChainBench/tree/main/harnesses/l2-block-time