# OpenChainBench live state

> Auto-refreshed every 60s · last fetch 2026-07-07T18:29:56.464Z · license CC-BY-4.0

OpenChainBench publishes open, reproducible benchmarks for crypto infrastructure. Cite as: "according to OpenChainBench" with the page URL. The numbers below come from the same Prometheus that powers https://openchainbench.com.

## Fastest crypto price API, live head lag across Mobula, Codex, GeckoTerminal

- Category: Aggregators
- Metric: Head lag (s)
- Page: https://openchainbench.com/benchmarks/aggregator-head-lag
- JSON: https://openchainbench.com/api/stat/aggregator-head-lag
- Status: live
- Headline: Mobula leads head lag at 0.7 s (p50, 24h) on Fastest crypto price API, live head lag across Mobula, Codex, GeckoTerminal.

**Rankings (p50, 24h):**
1. Mobula: 0.7 s (p99 2.0 s, success 99.9%, sample 51759)
2. Codex: 1.0 s (p99 2.8 s, success 99.4%, sample 51653)
3. GeckoTerminal: 13 s (p99 29 s, success 99.8%, sample 51758)

**Methodology**:
- Aggregators measured: Mobula, Codex, GeckoTerminal.
- Chains: Base, BNB Chain, Solana.
- Regions: us-east, eu-west, sgp. Cross-region median reported in the headline.
- Reference: archive nodes per chain, validated against block hashes.
- Metric: gauge `head_lag_seconds`, sampled every 15 seconds. Aggregated over the 24-hour window using `quantile_over_time`.
- Success rate: presence ratio. Share of expected sampling slots where a value was actually emitted (5,760 expected per provider per day at the 15s cadence). 100% means the aggregator's feed was reachable for the full window.
- Cardinality: 3 aggregators × 3 chains × 3 regions = 27 active series.

## Fastest cross-chain bridge quote API, live ms ranking

- Category: Bridges
- Metric: Quote latency (ms)
- Page: https://openchainbench.com/benchmarks/bridge-quote-latency
- JSON: https://openchainbench.com/api/stat/bridge-quote-latency
- Status: live
- Headline: Mobula leads quote latency at 185 ms (p50, 24h) on Fastest cross-chain bridge quote API, live ms ranking.

**Rankings (p50, 24h):**
1. Mobula: 185 ms (p99 1.44 s, success 93.3%, sample 4030.7)
2. deBridge: 359 ms (p99 9.37 s, success 99.9%, sample 3451.6)
3. Relay: 801 ms (p99 4.52 s, success 99.3%, sample 4290.74)
4. LI.FI: 1.48 s (p99 4.83 s, success 100.0%, sample 4319.75)
5. Near Intents: 2.00 s (p99 4.94 s, success 100.0%, sample 1728.3)

**Methodology**:
- Routes: USDC pairs spanning Solana, Base and Arbitrum.
- Notional sizes: $5, $50, $300 per quote.
- Cadence: full sweep (4 routes × 3 amounts × N bridges) every 5 minutes for 24 hours.
- Region: eu-west. Single point of measurement; multi-region requires running additional monitor instances.
- Histogram buckets: 50, 100, 200, 500, 1000, 2000, 5000, 10000 ms.
- Failures (quote_failed, execution_failed, unsupported route) excluded from latency aggregates and counted toward success rate.

## Cheapest cross-chain bridge for USDC at $300 notional

- Category: Bridges
- Metric: Effective fee (pct)
- Page: https://openchainbench.com/benchmarks/bridge-fee
- JSON: https://openchainbench.com/api/stat/bridge-fee
- Status: live
- Headline: Near Intents leads effective fee at 0.0092% (24h avg) on Cheapest cross-chain bridge for USDC at $300 notional.

**Rankings (p50, 24h):**
1. Near Intents: 0.0092% (p99 0.010%, success 100.0%, sample 11520)
2. Mobula: 0.10% (p99 0.12%, success 100.0%, sample 28800)
3. LI.FI: 0.33% (p99 0.76%, success 100.0%, sample 28800)
4. deBridge: 0.83% (p99 0.94%, success 99.9%, sample 23040)

**Methodology**:
- Routes: USDC pairs spanning Solana, Base and Arbitrum.
- Reference notional: $300 USDC. Smaller sizes ($5, $50) are captured by the harness but excluded from this report.
- Cost: `bridge_cost_percent{amount_usd="300"}`, in percent of notional. Includes fees + slippage + destination gas.
- Cadence: full sweep every 5 minutes for 24 hours.
- Region: eu-west. Single point of measurement; multi-region requires running additional monitor instances.
- Failures (quote_failed, unsupported route) excluded from cost aggregates and counted toward success rate.
- Provider types are surfaced as badges: direct protocols (deBridge) charge their own bridging fees; aggregators (LI.FI) route through whichever underlying bridge is cheapest, so their effective fee includes that bridge's cost plus any aggregator markup; intent / relay layers (Mobula, Relay) bake cost into the spread of a settlement intent rather than charging an explicit fee.

## Best crypto data API for token metadata, live across Mobula, Codex, Jupiter

- Category: Aggregators
- Metric: Field coverage (pct)
- Page: https://openchainbench.com/benchmarks/metadata-coverage
- JSON: https://openchainbench.com/api/stat/metadata-coverage
- Status: live
- Headline: Mobula leads field coverage at 65.6% (24h avg) on Best crypto data API for token metadata, live across Mobula, Codex, Jupiter.

**Rankings (p50, 24h):**
1. Mobula: 65.6% (p99 71.1%, success 100.0%, sample 89731.6)
2. Codex: 62.8% (p99 69.7%, success 100.0%, sample 89731.6)
3. Jupiter: 24.9% (p99 25.0%, success 100.0%, sample 69076)

**Methodology**:
- Token discovery: Mobula Pulse V2 WebSocket on `solana`, `evm:56` (BNB), `evm:8453` (Base) for known launchpads (pump.fun, Meteora DBC, Four.meme, Raydium CPMM, Zora, BaseApp, Bags, Moonshot).
- Coverage check: for each fresh token, query each aggregator's metadata endpoint and record whether `logo`, `description`, `twitter` and `website` are populated.
- Aggregators in scope: Mobula (`/api/2/token/details`), Codex (GraphQL `token` query, JWT-authenticated), Jupiter (`/v6/tokens/<mint>`, Solana only).
- Cadence: queue-driven; every newly-discovered token is checked once across the three aggregators. Steady-state ≈ several hundred checks per provider per hour.
- Region: `eu-west` (single point. multi-region requires running additional monitor instances).
- Ratio: `metadata_coverage_success_total / metadata_coverage_checks_total`, expressed in percent. Failures of the metadata API itself (timeouts, 5xx) are not counted in the denominator. only successful responses with the field check applied.
- Jupiter is Solana-only. it appears with zero coverage on EVM chains by construction; the cross-chain headline excludes Jupiter on chains it does not support.

## Crypto data API with most blockchains supported, live coverage ranking

- Category: Aggregators
- Metric: Networks supported (count)
- Page: https://openchainbench.com/benchmarks/network-coverage
- JSON: https://openchainbench.com/api/stat/network-coverage
- Status: live
- Headline: CoinPaprika leads networks supported at 306 (24h) on Crypto data API with most blockchains supported, live coverage ranking.

**Rankings (p50, 24h):**
1. CoinPaprika: 306 (p99 306, success 100.0%, sample 306)
2. GeckoTerminal: 266 (p99 266, success 100.0%, sample 266)
3. CoinStats: 151 (p99 151, success 100.0%, sample 151)
4. Codex: 121 (p99 121, success 100.0%, sample 121)
5. Mobula: 79 (p99 79, success 100.0%, sample 79)
6. Dune: 64 (p99 64, success 100.0%, sample 64)

**Methodology**:
- Source: each provider's public supported-networks endpoint.
- GeckoTerminal: GET /api/v2/networks (paginated, no auth).
- Codex: GraphQL `getNetworks` query at https://graph.codex.io/graphql with an official API key.
- Mobula: GET /api/1/blockchains with an Authorization API key.
- CoinPaprika: GET /v1/contracts (no auth). Lists platforms supported for contract lookup.
- CoinStats: GET /wallet/blockchains with X-API-KEY.
- Dune (via Sim API): GET https://api.sim.dune.com/v1/evm/supported-chains (no auth). EVM only, mainnets filtered via the `mainnet` tag.
- Cadence: full refresh every 6 hours.
- Counting: a provider's network is counted once per unique chain id; mainnet only.
- Failures (network errors, rate limits, auth errors) leave the previous count in place and increment a fetch_errors counter. the page falls back to its last successful sample.

## Fastest L1 blockchain finality, live across 11 chains

- Category: Blockchains
- Metric: Finality time (s)
- Page: https://openchainbench.com/benchmarks/l1-finality
- JSON: https://openchainbench.com/api/stat/l1-finality
- Status: live
- Headline: Gram leads finality time at 0.4 s (p50, 24h) on Fastest L1 blockchain finality, live across 11 chains.

**Rankings (p50, 24h):**
1. Gram: 0.4 s (p99 1.0 s, success 98.7%, sample 195781)
2. SUI: 0.5 s (p99 1.0 s, success 100.0%, sample 169996)
3. BNB: 1.0 s (p99 1.8 s, success 99.6%, sample 191096)
4. Avalanche: 1.4 s (p99 3.8 s, success 99.4%, sample 83400.5)
5. Stellar: 8.0 s (p99 8.0 s, success 0.2%, sample 0)
6. Solana: 13 s (p99 15 s, success 100.0%, sample 5760)
7. TRON: 57 s (p99 1.0 min, success 100.0%, sample 5760)
8. Ethereum: 15.9 min (p99 19.0 min, success 100.0%, sample 5760)
9. Monero: 20.2 min (p99 36.1 min, success 100.0%, sample 5760)
10. Litecoin: 29.1 min (p99 50.4 min, success 100.0%, sample 5760)

**Methodology**:
- Cadence: every 10 seconds for HTTP-polled chains, continuous WS for BNB and Avalanche.
- Ethereum: `eth_getBlockByNumber("latest")` minus `eth_getBlockByNumber("finalized")`.
- BNB / Avalanche (WS wall-clock): persistent `eth_subscribe("newHeads")` records T1 = first time block N is seen as latest. Periodic `eth_getBlockByNumber("finalized")` over same WS records T2 when N becomes finalized. lag = T2 − T1, ms precision, independent of chain timestamp resolution.
- Solana: `getSlot{commitment:"processed"}` + `getBlockTime` minus `getSlot{commitment:"finalized"}` + `getBlockTime`.
- TRON: `/wallet/getnowblock` (head) minus `/walletsolidity/getnowblock` (solidity-confirmed).
- Stellar (SSE wall-clock): Horizon `/ledgers?cursor=now&order=asc` event-stream records T1 on first sight of ledger N and T2 on the next ledger close (SCP-final at every close).
- SUI: `sui_getLatestCheckpointSequenceNumber` minus 5 checkpoints back.
- Gram: tonapi.io `/blockchain/masterchain-head` minus 3 seqno.
- Litecoin (probabilistic): blockchair `/stats.best_block_height` minus 6 confirmations via `/dashboards/block/{height}.block.time`.
- Monero (probabilistic): monero-rpc `get_info` minus 10 confirmations via `get_block_header_by_height`.
- Hedera (planned, currently disabled): mirror-node `/api/v1/blocks` only exposes already-final blocks, so true wall-clock lag is impossible from public endpoints. Re-enables once Block Nodes (HIP-1056) leave private preview.
- Result: `lag_seconds = headTimestamp, finalizedTimestamp`. We also record the block-height delta and per-chain fetch latency.
- Excluded by design: XRP (no close-time on `ledger_current`, wall-clock measurement requires WS subscribe to ledger stream, not yet implemented).
- Failures (5xx, timeouts, rate limits) leave the previous gauge in place and increment a per-chain `fetch_errors_total` counter; the page falls back to the last successful sample.

## Cheapest perp DEX, live all-in fee on a $1000 ETH 10x long

- Category: Trading
- Metric: All-in cost (bps)
- Page: https://openchainbench.com/benchmarks/perp-fees
- JSON: https://openchainbench.com/api/stat/perp-fees
- Status: live
- Headline: Lighter leads all-in cost at 0.0017% (24h avg) on Cheapest perp DEX, live all-in fee on a $1000 ETH 10x long.

**Rankings (p50, 24h):**
1. Lighter: 0.0017% (p99 0.010%, success 100.0%, sample 5760)
2. gains.trade: 0.040% (p99 0.040%, success 100.0%, sample 5760)
3. Hyperliquid: 0.046% (p99 0.057%, success 100.0%, sample 5760)
4. dYdX v4: 0.053% (p99 0.074%, success 100.0%, sample 5760)
5. GMX v2: 0.060% (p99 0.060%, success 99.3%, sample 5760)

**Methodology**:
- Cadence: every 5 minutes, in parallel across all venues.
- Trade simulated: ETH long 10x, $1000 notional ($100 collateral).
- Hyperliquid: `POST /info {type: l2Book}` for asks + `{type: userFees, user: 0x000...000}` for taker fee + `{type: metaAndAssetCtxs}` for funding.
- dYdX v4: indexer `/orderbooks/perpetualMarket/ETH-USD` + `/perpetualMarkets` (funding) + Cosmos REST `/dydxprotocol/v4/feetiers/perpetual_fee_params` for tier-0 default fee.
- GMX v2 (Arbitrum): Subsquid GraphQL on the synthetics-arbitrum subgraph for `positionFeeFactorForNegativeImpact` (worst-case open) + gmxinfra REST for funding.
- Lighter: `/orderBookDetails` (taker fee per market) + `/orderBookOrders` (orderbook walk).
- gains.trade (Gains v8 on Base): we read the fee directly on-chain. `eth_call pairs(N)` to find the pair index for the asset and its `feeIndex`, then `eth_call fees(feeIndex).openFeeP` for the actual taker fee. Spread comes from `pairs(N).spreadP`. Both values in 1e10 precision per Gains v8 convention. Cached 1h to keep Base RPC quota low.
- All-in formula: `all_in_bps = taker_fee_bps + spread_bps`. Both components emitted as separate metrics for transparency.
- Failures (5xx, timeouts, rate limits) leave the previous gauge in place and increment a per-venue `fetch_errors_total` counter. The page falls back to the last successful sample.

## Best wallet labeling API provider

- Category: Aggregators
- Metric: Coverage rate (pct)
- Page: https://openchainbench.com/benchmarks/wallet-labels-coverage
- JSON: https://openchainbench.com/api/stat/wallet-labels-coverage
- Status: live
- Headline: Helius leads coverage rate at 84.2% (24h avg) on Best wallet labeling API provider.

**Rankings (p50, 24h):**
1. Helius: 84.2% (p99 84.2%, success 100.0%, sample 923.16)
2. XRPScan: 80.2% (p99 80.2%, success 90.1%, sample 486.084)
3. StellarExpert: 80.0% (p99 80.0%, success 80.0%, sample 485.084)
4. Blockscout: 53.5% (p99 53.5%, success 94.7%, sample 4028.7)
5. OLI: 50.5% (p99 50.5%, success 100.0%, sample 5578.97)
6. Mobula: 43.2% (p99 43.2%, success 100.0%, sample 8639.5)
7. TonAPI: 35.6% (p99 35.6%, success 78.5%, sample 680.118)
8. WalletExplorer: 20.0% (p99 20.0%, success 100.0%, sample 486.084)
9. Moralis: 14.3% (p99 14.3%, success 31.0%, sample 1325.23)

**Methodology**:
- Sample: ~180 curated anchor addresses across 11 chains (CEX hot wallets, DEX routers, Safe multisigs, OFAC SDN, public figures, verified smart contracts), shuffled and re-checked every 30 minutes. List rotated quarterly from public sources.
- Each anchor is tagged with a kind: `contract` (verified smart contracts where a non-generic name comes from source code) or `eoa` (externally-owned accounts where the name must come from a curated entity graph). The kind is set at curation time using an on-chain code probe (eth_getCode for EVM, equivalent RPC for non-EVM).
- Kind tab on the bench page: `contract` measures contract-name resolution (easy for any explorer reading verified source), `eoa` measures entity resolution on plain wallets (the curated-graph job). The two views are separate Prometheus queries with `kind="contract"` and `kind="eoa"` injected into every selector.
- Query each provider's labels endpoint live: Mobula `/api/2/wallet/labels`, Helius `/v1/wallet/{addr}/identity`, Moralis `/api/v2.2/entities`, Blockscout `/api/v2/addresses/{addr}`, OLI Base EAS GraphQL, TonAPI `/v2/accounts/{addr}`, StellarExpert `/explorer/directory/{addr}`, XRPScan `/api/v1/account/{addr}`, WalletExplorer `/api/1/address-lookup`.
- A provider scores 'hit' when it returns a non-generic entity name. Filler labels like 'EOA', 'Contract', 'Wallet', 'Multisig', 'Unknown' are explicitly excluded, they carry no entity signal.
- Per-chain leaderboards. providers are filtered by their declared chain support, so Helius (Solana-only) doesn't get penalized on Ethereum and vice versa.
- Failures (timeouts, 5xx, auth errors) are counted as 'no label' and surfaced separately as `wallet_labels_fetch_errors_total`.
- Region: `eu-west` (single point).

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

- Category: Blockchains
- Metric: Block time (ms)
- Page: https://openchainbench.com/benchmarks/l2-block-time
- JSON: https://openchainbench.com/api/stat/l2-block-time
- Status: live
- Headline: Arbitrum One leads block time at 285 ms (p50, 24h) on Fastest L2 block time, live across Arbitrum, Base, Optimism and 6 more.

**Rankings (p50, 24h):**
1. Arbitrum One: 285 ms (p99 497 ms, success 99.8%, sample 344638)
2. zkSync Era: 1.66 s (p99 50.41 s, success 99.7%, sample 16001.8)
3. Mantle: 1.80 s (p99 2.98 s, success 99.6%, sample 43008.5)
4. Optimism: 1.95 s (p99 2.98 s, success 99.1%, sample 42300.3)
5. Taiko: 1.99 s (p99 4.54 s, success 99.7%, sample 42983.5)
6. Blast: 1.99 s (p99 2.98 s, success 99.8%, sample 43103.5)
7. Base: 2.03 s (p99 2.98 s, success 99.7%, sample 43070.5)
8. Scroll: 4.24 s (p99 59.87 s, success 99.2%, sample 9237.61)
9. Linea: 5.57 s (p99 48.82 s, success 99.7%, sample 9996.74)

**Methodology**:
- 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.

## Fastest free public RPC for Ethereum, BNB, Polygon and 7 more EVM chains

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/rpc-capabilities
- JSON: https://openchainbench.com/api/stat/rpc-capabilities
- Status: live
- Headline: Binance leads rpc latency at 72 ms (p50, 24h) on Fastest free public RPC for Ethereum, BNB, Polygon and 7 more EVM chains.

**Rankings (p50, 24h):**
1. Binance: 72 ms (p99 82 ms, success 100.0%, sample 8640.82)
2. PublicNode: 140 ms (p99 1.09 s, success 99.9%, sample 181383)
3. Avalanche: 198 ms (p99 278 ms, success 100.0%, sample 8639.82)
4. Nodies: 199 ms (p99 302 ms, success 75.0%, sample 69111.5)
5. dRPC: 204 ms (p99 617 ms, success 81.2%, sample 190047)
6. Merkle: 242 ms (p99 581 ms, success 81.7%, sample 17277.5)
7. Arbitrum: 247 ms (p99 351 ms, success 100.0%, sample 8640.82)
8. Base: 262 ms (p99 1.27 s, success 100.0%, sample 8638.82)
9. MeowRPC: 281 ms (p99 531 ms, success 98.9%, sample 17275.6)
10. Tenderly: 315 ms (p99 475 ms, success 99.9%, sample 172776)
11. Optimism: 330 ms (p99 351 ms, success 99.9%, sample 8640.82)
12. Lava: 384 ms (p99 2.50 s, success 99.4%, sample 25912.5)
13. Flashbots: 688 ms (p99 970 ms, success 100.0%, sample 8640.82)
14. 1RPC: 1.19 s (p99 4.06 s, success 0.6%, sample 129566)

**Methodology**:
- Cadence: every 15 seconds per (provider, chain) pair, from each of 3 Railway replicas (us-east Virginia, eu-west Amsterdam, sgp Singapore). The harness reads `$RAILWAY_REPLICA_REGION` at boot, normalizes it to the canonical 3-region set, and stamps a `region` label on every emitted metric. Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are available on the time-series chart.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side `time.Now()` delta around the round-trip, in milliseconds. Exposed as both a gauge (`rpc_latency_milliseconds`) and a histogram (`rpc_latency_milliseconds_histogram`) with buckets 50 ms → 10 s, so p50/p90/p99 are computed via Prometheus `histogram_quantile` / `quantile_over_time`.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err` (status ≠ 200 or transport failure), `jsonrpc_err` (HTTP 200 with an `error` field, the Cloudflare-eth trap), `stale` (returned block more than 20 behind the cross-provider tip for that chain), `timeout`. Counter `rpc_call_total{result}` powers the reliability leaderboard.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head, depth) for `depth` in {300, 7200, 216_000, 1_296_000, 5_000_000}. Gauge `rpc_archive_depth_supported{depth}` is 1 when the response is non-pruned, 0 otherwise. The 300/7200 thresholds cover Geth's default pruned-cap range; 216k ≈ 1 month; 1.3M ≈ 6 months; 5M ≈ genesis-era full archive.
- Chain coverage: 10 EVM chains. Ethereum (9 providers), Arbitrum (8), Base (6), Optimism (6), Avalanche (6), BNB (5), Polygon (5), Linea (4), Scroll (4), Mantle (4). Provider matrix per chain is documented in `miniapps/rpc-capabilities/cmd/script/config.go`.
- Excluded by design: Ankr (key-gated), gateway.fm (29 req/IP budget too tight for 15s polling), LlamaRPC + BlockPI + OmniaTech (Cloudflare 521 region-blocked), Alchemy demo (rate-limited dead), NodeReal + GetBlock + Chainstack (key-gated). Merkle on Ethereum + Lava on non-ETH/Arb + MeowRPC on non-ETH/Arb all excluded chain-by-chain. Every (provider, chain) was live-verified no-key before inclusion.

## Most accurate gas oracle, live gap vs realized priority fee

- Category: RPCs
- Metric: Gap vs realized (gwei) (count)
- Page: https://openchainbench.com/benchmarks/gas-estimation
- JSON: https://openchainbench.com/api/stat/gas-estimation
- Status: live
- Headline: Owlracle leads gap vs realized (gwei) at 0.113 (24h) on Most accurate gas oracle, live gap vs realized priority fee.

**Rankings (p50, 24h):**
1. Owlracle: 0.113 (p99 0, success 49.2%, sample 4320.75)
2. Etherscan: 1.07 (p99 ~0, success 94.1%, sample 11520)
3. PublicNode: 1.5 (p99 0, success 100.0%, sample 21600.8)

**Methodology**:
- Chains: Ethereum mainnet (chainid=1), Polygon PoS (chainid=137). Both are EIP-1559 with proper dynamic base fee, so priority-fee prediction is apples-to-apples comparable. BNB Chain excluded (not EIP-1559). Avalanche C-Chain excluded (auto-tuning drives priority fee to ~0, prediction-error collapses to ~0).
- Oracles per chain. Ethereum + Polygon: PublicNode feeHistory, Owlracle, Etherscan v2 (free tier).
- Per-oracle endpoints. PublicNode `eth_feeHistory` on each chain's RPC; Owlracle `/v4/{eth|poly}/gas` (slug per chain); Etherscan v2 `?chainid=<N>&module=gastracker&action=gasoracle`.
- Cadences. PublicNode feeHistory every 12s per chain; Owlracle every 60s per chain (free quota ceiling); Etherscan every 15s per chain with a global rate-gate enforcing ≥6s between any two Etherscan requests across chains (no-key limit is 1 req/5s per IP, shared).
- Tier normalization. Each oracle's named tiers (fast / standard / slow / safe / propose) are mapped onto a unified p25 / p50 / p75 / p90 / p99 scheme. The leaderboard ranks the p50 tier (the standard speed wallets use by default).
- Realized priority fee. For each pending block, the harness pulls the full block via `eth_getBlockByNumber(.., true)` on the chain's PublicNode RPC and computes the percentile from actual `maxPriorityFeePerGas` values across every included transaction. Empty or low-tx blocks (`gas_realized_tx_count` near zero) are surfaced separately because the realized percentile is noisy when tx count is low.
- Realized base fee. Recorded for completeness as `gas_realized_base_gwei{chain}` and per-oracle baseFee error as `gas_error_base_gwei{oracle, chain}`. Not the ranking signal since every EIP-1559 oracle inherits this from `eth_feeHistory` and converges.
- Pending buffer. Per (oracle, chain) in-memory map of predictions waiting on a realized block. TTL is ~25 blocks (~5 minutes on Ethereum, ~50 seconds on Polygon due to faster blocks). Beyond that, predictions are dropped as no-longer-informative. Buffer growth surfaces via `gas_pending_buffer_size{oracle, chain}`.
- Polling result classification. `ok`, `http_err`, `parse_err`, `throttled` (HTTP 429 or oracle-specific quota message), `timeout`. Counter `gas_oracle_call_total{oracle, result, chain}` powers the reliability column.
- Ranking metric. The table ranks on the p99 of the absolute gap over 24h, not the p50. At current fee levels the typical-minute gaps are fractions of a micro-gwei apart across oracles (ranking noise); the p99 captures behaviour during the volatile minutes where a wrong prediction either overpays or misses the block. The typical p50 and p90 gaps stay visible as secondary columns.
- Covered rate. Share of time (24h) each oracle's posted p50-tier prediction was at or above the realized p50 priority fee, recorded as `ocb:gas_p50_covered:pct_24h` via a recording rule. Same-instant gauge comparison (current prediction vs latest realized block), a proxy pending a harness-side matched counter. High = errs on the side of inclusion; low = under-bids vs the block's realized median.
- Excluded by design. (a) BNB Chain (not EIP-1559). (b) L2 OP Stack chains (Optimism, Base, Arbitrum), priority fee ≈ 0 there because sequencer is centralised, the relevant cost is L1 data fee which is a different metric and belongs in a separate bench. (c) Rough median oracles that publish only a single number (no tier breakdown). (d) Solana, different fee model entirely (lamports per CU, MEV via Jito), separate bench needed.

## Most stable stablecoin, live peg deviation across USDC, USDT and DAI

- Category: Trading
- Metric: Peg deviation (bps)
- Page: https://openchainbench.com/benchmarks/stablecoin-peg
- JSON: https://openchainbench.com/api/stat/stablecoin-peg
- Status: live
- Headline: DAI leads peg deviation at 0.016% (24h avg) on Most stable stablecoin, live peg deviation across USDC, USDT and DAI.

**Rankings (p50, 24h):**
1. DAI: 0.016% (p99 0.022%, success 100.0%, sample 14400.5)
2. USDC: 0.025% (p99 0.035%, success 100.0%, sample 51837)
3. USDT: 0.087% (p99 0.11%, success 99.9%, sample 34557)

**Methodology**:
- Sources per stable, USDC: Binance USDC/USDT (USDT-anchored, secondary), Kraken USDCUSD, Bitstamp usdcusd. USDT: Kraken USDTUSD, Bitstamp usdtusd. FDUSD: Binance FDUSDUSDT (USDT-anchored, secondary). USDe: Binance USDEUSDT (USDT-anchored, secondary). DAI: Curve 3pool `get_dy` forward (USDC → DAI) and reverse (DAI → USDC).
- Cadence: 5 seconds for CEX REST tickers, 12 seconds for Curve `get_dy` on-chain (matches Ethereum block time). Per-venue samples are grouped into 60-second buckets for the liquidity-weighted median aggregation.
- Aggregation: per-minute liquidity-weighted median across USD-quoted venues (`Quote = QuoteUSD`). Weight is 24 h USD volume estimate. The aggregated price drives `peg_deviation_bps` (per-minute median, retained for backward compatibility) and `peg_deviation_bps_histogram`.
- Primary headline: `peg_deviation_worst_bps`, the per-minute MAX |price - $1.00| across all venue samples in the 60-second bucket, in basis points. The leaderboard ranks stables on `quantile_over_time(0.99, peg_deviation_worst_bps[24h])`. Per-minute max surfaces sub-minute depeg wicks that a median would smooth away, matching the OHLC convention of TradFi reference rates. Gauges `peg_minute_min_bps`, `peg_minute_open_bps`, `peg_minute_close_bps` expose the bar shape.
- Cross-venue gap (OCB-only number): `max(price across USD-quoted venues) - min(price)`, per minute, in basis points. Surfaces the windows where Coinbase quotes $1.0003 while Kraken quotes $0.9978. Stored as `peg_cross_venue_gap_bps`.
- USDT-anchored secondary metric: Binance USDC/USDT, FDUSD/USDT and USDE/USDT are exposed on `peg_deviation_usdt_anchored_bps{venue}` separately so the USD-anchored primary leaderboard is not contaminated by USDT's own peg deviation.
- Time outside band: total seconds in the trailing 24 h during which the per-minute aggregated price fell outside [0.995, 1.005] (±50 bps). Split into `peg_time_below_peg_24h_seconds` (< 0.995) and `peg_time_above_peg_24h_seconds` (> 1.005) because Circle redemption only clears above-peg, so the direction tells you which failure mode is active.
- Depeg event flag: binary `peg_depeg_event_flag` set to 1 when the per-minute aggregated price has been outside [0.97, 1.03] for ≥5 consecutive minutes; cleared after 30 minutes back inside. Conservative so it does not flap during normal stress events.
- Outlier rule (multi-venue consensus): a sample more than 2% off peg is kept only when at least one other venue was outside the same band in the same direction within the last 30 seconds. Isolated single-venue glitches are dropped as `dropped_isolated`; corroborated moves (Kraken AND Bitstamp both at $0.87) are kept as `kept_corroborated`, so a real depeg like USDC during SVB in March 2023 survives into the percentile metric. Anything more than 50% off peg is treated as a parser bug and dropped.
- Excluded by design: aggregator-only prices (CoinGecko, Coinmarketcap, DefiLlama) because they are themselves liquidity-weighted medians of the venues we already poll directly. Algo-stables that have already failed (UST, USDR) are out of scope; the bench tracks live, currently-redeemable stables.

## Cheapest USDT stablecoin swap on Binance, live USDC, FDUSD, USDe spread

- Category: Trading
- Metric: USDT-pair spread (bps)
- Page: https://openchainbench.com/benchmarks/stablecoin-peg-usdt-anchored
- JSON: https://openchainbench.com/api/stat/stablecoin-peg-usdt-anchored
- Status: live
- Headline: USDe leads usdt-pair spread at 0.055% (24h avg) on Cheapest USDT stablecoin swap on Binance, live USDC, FDUSD, USDe spread.

**Rankings (p50, 24h):**
1. USDe: 0.055% (p99 0.055%, success 100.0%, sample 17280)
2. USDC: 0.060% (p99 0.084%, success 100.0%, sample 17280)
3. FDUSD: 0.17% (p99 0.20%, success 100.0%, sample 17280)

**Methodology**:
- Source: Binance REST `/api/v3/ticker/bookTicker?symbol=<pair>` polled every 5 seconds per pair. No API key required. Mid-price = (bid + ask) / 2 in USDT.
- Pairs: USDCUSDT ($2.8B daily, reference anchor for USDT-vs-USD drift), FDUSDUSDT ($41M daily, FDUSD's primary book), USDEUSDT ($1.8M daily, the book that flashed to $0.65 on October 10 2025).
- Metric: `peg_deviation_usdt_anchored_bps{stable, venue="binance"}` = |mid_price - 1.0000| × 10000. 1 bp = 0.01% = 0.0001 USDT off pair-reference.
- Aggregation: p50 / p90 / p99 over 24 hours via Prometheus `quantile_over_time`. p99 is the headline because swap cost during stress is what matters for inventory rotation, not the calm-minute median.
- USDC reference anchor: USDC/USDT spread is the floor below which no other pair can credibly score, because that gap reflects USDT's own drift away from USD reaching back into the pair. Read other stables' true vs-USDT drift as `their_p99 - usdc_p99` to control for it.
- Depeg event flag (shared with bench № 014): binary `peg_depeg_event_flag{stable}` fires when the per-minute aggregated price is outside [0.97, 1.03] for ≥5 consecutive minutes. The flag clears after 30 minutes back inside the band. Conservative so it does not flap during normal stress.
- Out of scope: this is a swap-cost / pair-spread bench, NOT a peg-robustness bench. Reserve attestations, basis-trade health, redemption windows, on-chain pool liquidity and other fundamental peg signals live on `stablecoin-peg` (bench № 014) or off-chain in each issuer's transparency dashboard.

## DeFi token buyback tracker, live executed vs promised ratio

- Category: Trading
- Metric: Execution ratio (pct)
- Page: https://openchainbench.com/benchmarks/buyback-audit
- JSON: https://openchainbench.com/api/stat/buyback-audit
- Status: live
- Headline: Hyperliquid leads execution ratio at 0.94% (24h avg) on DeFi token buyback tracker, live executed vs promised ratio.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.94% (p99 0.94%, success 96.9%, sample 9442520)
2. Sky (Maker): 0.083% (p99 0.083%, success 99.7%, sample 256529)

**Methodology**:
- Promised USD, DeFiLlama `summary/fees/<protocol>` endpoint, summed over the rolling window, multiplied by the protocol's documented buyback share. Hyperliquid: `hyperliquid` slug, share 0.97 (HyperCore fees → Assistance Fund). Sky: `makerdao` slug, share 1.00 (Maker / Sky protocol surplus → SBE).
- Executed USD, Hyperliquid, HYPE buys credited to the Assistance Fund multisig `0xfefefefefefefefefefefefefefefefefefefefe` on HyperCore, retrieved from the Hyperliquid `info` API user fills endpoint. Quantity is converted to USD using the on-chain oracle price returned by `metaAndAssetCtxs` because that is the price the AF actually pays at execution, not a CEX index.
- Executed USD, Sky, SKY ERC-20 inflows into the SBE receiver `0xBE8E3e3618f7474F8cB1d074A26afFef007E98FB` on Ethereum mainnet, paginated through Etherscan v2 (`chainid=1`, single API key for the whole multichain unified endpoint). Quantity is decoded with the SKY contract's 18 decimals and priced at the CoinGecko `sky` spot at scrape time.
- Windows, rolling 7d and 30d. The harness recomputes the full window's sums each scrape rather than maintaining a delta, so historical revisions of DeFiLlama's fees series propagate automatically and no state leaks across restarts.
- Cadence, 5 minutes per protocol. The numbers are gauges, not counters; sub-5-minute resolution is meaningless because both promised and executed sides are bounded by minutes-to-hours-grain upstream data (DeFiLlama daily aggregation, on-chain block time).
- Excluded, GMX. V2 does not run a single on-market buyback wallet whose inflows we can audit. Fees flow to GLP / GM pool LPs in ETH and stables and to GMX stakers via esGMX reward distributors. The original treasury `0x68863dDE…dea6A` has been dormant since 2022-08 (verified via Etherscan v2), so there is no executor address that would let an audit of this shape resolve. v2 of this bench will add Jupiter Litterbox Trust (50% fees → JUP buyback on Solana) and Aave AFC as cleaner replacements.
- Pricing, CoinGecko free tier (`hyperliquid`, `sky`) for the executed-side USD valuation. For Hyperliquid the on-chain oracle from `metaAndAssetCtxs` is preferred when available because that is the AF's actual fill reference, not a delayed third-party median. Aggregator drift between CoinGecko and the on-chain oracle is typically < 50 bps and is dwarfed by the ratio's own measurement scale.
- Honesty boundary, the ratio measures execution against a documented promise. It does not measure whether the promise itself is generous or stingy, whether the bought-back token is held vs burned vs redistributed, or whether the buy was timed adversarially. Those are separate benchmarks that this one explicitly does not try to answer.

## Chainlink vs Pyth vs Binance vs Coinbase, live oracle deviation

- Category: Trading
- Metric: Max cross-oracle deviation (bps)
- Page: https://openchainbench.com/benchmarks/oracle-deviation
- JSON: https://openchainbench.com/api/stat/oracle-deviation
- Status: live
- Headline: XRP/USD leads max cross-oracle deviation at 0.044% (24h avg) on Chainlink vs Pyth vs Binance vs Coinbase, live oracle deviation.

**Rankings (p50, 24h):**
1. XRP/USD: 0.044% (p99 0.13%, success 100.0%, sample 3)
2. DOGE/USD: 0.047% (p99 0.15%, success 100.0%, sample 3)
3. LINK/USD: 0.050% (p99 0.15%, success 100.0%, sample 4)
4. BNB/USD: 0.052% (p99 0.13%, success 100.0%, sample 4)
5. ADA/USD: 0.054% (p99 0.17%, success 100.0%, sample 3)
6. ETH/USD: 0.079% (p99 0.15%, success 100.0%, sample 4)
7. AVAX/USD: 0.080% (p99 0.22%, success 100.0%, sample 4)
8. BTC/USD: 0.082% (p99 0.13%, success 100.0%, sample 4)
9. SOL/USD: 0.085% (p99 0.15%, success 100.0%, sample 4)
10. POL/USD: 0.092% (p99 0.40%, success 100.0%, sample 4)

**Methodology**:
- Sources. Chainlink AggregatorV3 via `eth_call(latestRoundData())` on Ethereum mainnet (no API key, public RPC with fallback), Pyth Network via Hermes REST `/api/latest_price_feeds` batch endpoint (no key), Binance REST `/api/v3/ticker/price` on USDT-quoted symbols (treated as ≈ USD), Coinbase REST `/products/<P>/ticker` on USD-quoted products. All four are free, no-auth, public endpoints.
- Pairs (10). BTC, ETH, SOL, BNB, AVAX, LINK and POL are tracked on all 4 sources. XRP, ADA, DOGE are tracked on 3 sources (Pyth + Binance + Coinbase) because the Chainlink mainnet AggregatorV3 contracts for these USD feeds are deprecated and no longer updated by node operators, the provider tag flags it.
- Cadence. 30 second polling interval per (source, pair). 4 sources × 10 pairs × 2/minute = 80 requests/minute total, comfortably under every free-tier ceiling (Binance 1200/min, Coinbase 10/s public, Pyth ~30/s soft, public RPC courteous). HTTP timeout is 8 s per request to match the gas-estimation harness.
- Deviation formula. For every unordered pair of sources `(a, b)` that both have a fresh sample for the same pair: `deviation_pct = |price_a - price_b| / ((price_a + price_b) / 2) * 100`. With 4 sources we compute 6 pairwise deviations per asset; with 3 sources we compute 3. Per-pair headline is the max across all source-pairs (`ocb_oracle_max_deviation_pct`).
- Stale-price guard. A source's sample is considered stale and excluded from the deviation calculation if its last successful update is older than `2 * pollInterval` (60 s). Prevents a dead Coinbase ticker from registering as a 0% deviation against itself by leaving the price gauge fossilized.
- Chainlink round age. The on-chain `updatedAt` timestamp from `latestRoundData()` is published separately as `ocb_oracle_last_round_age_seconds{source="chainlink", pair}`. Chainlink updates only on deviation (typically 0.25-0.5% for blue chips) or heartbeat (~1 h), so a 30-minute age on a quiet ETH minute is normal; a 2-hour age on SOL during a volatile minute is the actual signal.
- USDT ≈ USD assumption. Binance only quotes USDT pairs (BTCUSDT, etc.). We treat USDT as ≈ USD ± 10 bps drift, which is acceptable for a bench whose alert floor is ≥ 10 bps. A real USDT depeg would surface as Binance drifting from the other three sources for *every* pair simultaneously, exactly what we want this bench to flag, not hide.
- MATIC → POL migration. Polygon migrated MATIC → POL 1:1 on Sep 4 2024. The Chainlink mainnet feed contract is still named MATIC/USD but on-chain `description()` confirms it tracks the POL token; Pyth renamed the feed to POL/USD; Coinbase delisted MATIC-USD and only lists POL-USD; Binance kept MATICUSDT as a frozen historical pair AND lists POLUSDT. We point Binance at POLUSDT so all four sources track the same underlying asset. Bench label is kept as `pair="MATIC/USD"` for query continuity.
- Time-aligned deviation (canonical headline). For every source pair we anchor on the more recent SourceTS (Chainlink's on-chain `updatedAt`, fetch time for continuous sources) and look up the older source's price in a 30-minute rolling history at that moment. Published as `ocb_oracle_deviation_at_oracle_ts_pct`, feeding `ocb_oracle_max_deviation_pct`. Removes Chainlink heartbeat-lag inflating deviation; alignment misses count as `ocb_oracle_alignment_miss_total`.
- Excluded by design. Redstone (push-pull, no continuous gauge to scrape without integration contract), Uniswap V3 TWAP (per-pool integration + derivation of same CEX prints), DIA (smaller footprint than the four kept), and aggregator-of-aggregators (CoinGecko, CMC, DefiLlama), re-aggregating already-aggregated data adds latency and hides per-source disagreement.

## Highest staking yield, live validator net APR across Solana and Hyperliquid

- Category: Blockchains
- Metric: Net yield (bps)
- Page: https://openchainbench.com/benchmarks/validator-yield
- JSON: https://openchainbench.com/api/stat/validator-yield
- Status: live
- Headline: Solana leads net yield at 5.49% (24h avg) on Highest staking yield, live validator net APR across Solana and Hyperliquid.

**Rankings (p50, 24h):**
1. Solana: 5.49% (p99 5.85%, success 100.0%, sample 200)
2. Hyperliquid: 2.17% (p99 2.24%, success 100.0%, sample 33)

**Methodology**:
- Sources. Solana primary: `GET api.stakewiz.com/validators` (free, no key). `total_apy` already includes inflation + Jito MEV tips. Solana enrichment: `GET kobe.mainnet.jito.network/api/v1/validators` for MEV-share split. Hyperliquid: `POST api.hyperliquid.xyz/info {type:validatorSummaries}`, field `predictedApr.day` × `uptimeFraction`. Prices: CoinGecko (SOL/USD), HL `metaAndAssetCtxs` (HYPE/USD).
- Cadence. 5-minute scrape interval per chain. Validator-level metrics (APR, commission, uptime, stake) move on epoch boundaries (~2 days on Solana, ~30 seconds on Hyperliquid), so sub-minute polling would add Prom cardinality cost without information.
- Net yield formula. `net_yield_bps = gross_apr_bps × uptime_fraction`. Slashing is treated as negligible in v1, Solana has never slashed in production, and Hyperliquid's jailed-validator state is surfaced as `ocb_validator_jailed{chain, validator}=1` separately rather than amortised into the APR. Both chains report APR (simple yield), not APY (compounded); the bench reports APR-as-bps to match what the upstream APIs publish, no compounding adjustment applied.
- Cap. Solana exposes ~3000 active validators across the full set; the bench caps to the top 200 by `activated_stake` (USD-weighted) to keep Prom cardinality at ~230 series total across the two chains. The top 200 represent ~90% of staked SOL by value, so the median is representative of where real stake sits, not of the long tail of <1k SOL validators. Hyperliquid exposes ~30 active validators total, all are tracked.
- Median (chain-level headline). `ocb_chain_median_net_yield_bps{chain}` is computed harness-side over the per-validator gauges every scrape, not derived from Prom. This includes the ~42 Solana validators currently at 0% APY (commission 100% or no leader slots), which materially pulls the Solana median down vs the modal active-validator yield. A reader who wants 'yield I would get if I picked a sane validator' should look at p75 or higher on the Solana distribution, not the chain median.
- MEV treatment. Solana: MEV tips from Jito are already folded into Stakewiz `total_apy`. `ocb_validator_mev_share_bps` is exposed for transparency (a reader sees 'Helius APR 600 bps of which 80 bps MEV') but NOT subtracted to produce a 'staking-only' figure. Hyperliquid: no separate MEV layer (centralised sequencer captures order-flow value at the protocol level), so the MEV gauge is 0 by convention.
- Jailed / inactive handling. Hyperliquid: `jailed=1` validators (currently 4) land in the dataset with `predictedApr=0`, so `net_yield_bps=0`. Solana: ~42 validators report `total_apy=0`. Live data shows two causes: commission 100% (operator routes everything to themselves, delegators get 0) or zero leader slots this epoch (no block-production rewards). Both legitimate transient states, both count toward total + median.
- Excluded by design. Ethereum validator yield (deferred v2, beacon-node ~1 TB or MEV-Boost relay scraping required, neither is a 5-min poll). Lido / Rocket Pool / Coinbase staked-ETH are products with own fee structures, not validator yields (separate bench `liquid-staking-yield`, future). Cosmos, Polkadot, Avalanche out of scope v1, chain-specific sources would dilute focus.

## Hyperliquid frontends builder revenue leaderboard

- Category: Trading
- Metric: Builder fees collected (USD) (usd)
- Page: https://openchainbench.com/benchmarks/hyperliquid-frontends
- JSON: https://openchainbench.com/api/stat/hyperliquid-frontends
- Status: live
- Headline: Phantom leads builder fees collected (usd) at $73.9K (24h) on Hyperliquid frontends builder revenue leaderboard.

**Rankings (p50, 24h):**
1. Phantom: $73.9K (p99 $22.8, success 100.0%, sample 41373)
2. MetaMask: $20.9K (p99 $17.83, success 100.0%, sample 10919)
3. Invo: $16.3K (p99 $1.92, success 100.0%, sample 107370)
4. Insilico: $9,694.01 (p99 $35.64, success 100.0%, sample 29131)
5. 0xdbc2…97a6: $8,469.79 (p99 $114.46, success 100.0%, sample 1095)
6. FOMO: $8,258.05 (p99 $20.39, success 100.0%, sample 7385)
7. OneKey: $7,648.18 (p99 $68.29, success 100.0%, sample 2770)
8. Rabby: $6,294.49 (p99 $8.43, success 100.0%, sample 12802)
9. 0x7cc0…e781: $6,265.25 (p99 $2.38, success 100.0%, sample 20132)
10. Legend Trade: $5,525.69 (p99 $60.72, success 100.0%, sample 2628)
11. Liquid Perps: $4,006.52 (p99 $7.72, success 100.0%, sample 8218)
12. BullpenFi: $3,401.93 (p99 $12.33, success 100.0%, sample 5217)
13. Tread.fi: $3,288.27 (p99 $25.1, success 100.0%, sample 54852)
14. 0x42f3…f992: $3,132.19 (p99 $24.09, success 100.0%, sample 3362)
15. Axiom: $2,558.02 (p99 $11.22, success 100.0%, sample 4483)
16. Metascalp: $2,474.08 (p99 $12.13, success 100.0%, sample 76771)
17. Dreamcash: $1,756.89 (p99 $6.25, success 100.0%, sample 3055)
18. Nansen: $1,520.24 (p99 $9.44, success 100.0%, sample 4539)
19. based.app: $1,322.75 (p99 $3.21, success 100.0%, sample 7622)
20. Sushi: $985.09 (p99 $164.18, success 100.0%, sample 176)
21. Moonbot: $981.38 (p99 $13.09, success 100.0%, sample 4234)
22. Bitget Wallet: $852.82 (p99 $7.61, success 100.0%, sample 1066)
23. cro.trade: $831.14 (p99 $59.37, success 100.0%, sample 383)
24. STRYX: $820.25 (p99 $410.13, success 100.0%, sample 133)
25. Mass.money: $811.55 (p99 $17.64, success 100.0%, sample 852)
26. Splash: $745.05 (p99 $106.44, success 100.0%, sample 478)
27. Pear: $725.41 (p99 $8.74, success 100.0%, sample 2450)
28. MetaMask (alt): $722.04 (p99 $11.28, success 100.0%, sample 619)
29. Hyperdash: $711.51 (p99 $3.58, success 100.0%, sample 4165)
30. 0xb290…c34a: $679.08 (p99 $20.58, success 100.0%, sample 1391)
31. Infinex: $624.17 (p99 $17.83, success 100.0%, sample 573)
32. MinaraAI: $588.23 (p99 $0.8913, success 100.0%, sample 72100)
33. Markets Mobile: $502.38 (p99 $7.08, success 100.0%, sample 697)
34. pvp.trade: $458.12 (p99 $11.17, success 100.0%, sample 559)
35. Trust Wallet: $440.24 (p99 $0.6701, success 100.0%, sample 10784)
36. Tradoor: $384.88 (p99 $17.49, success 100.0%, sample 23915)
37. MarsGO: $317.97 (p99 $24.46, success 100.0%, sample 362)
38. 0xc95d…1aca: $317.55 (p99 $28.87, success 100.0%, sample 9960)
39. 0x446f…d6c6: $311.96 (p99 $31.2, success 100.0%, sample 393)
40. ApexLiquid: $304.14 (p99 $3.62, success 100.0%, sample 4905)
41. Rainbow: $281.85 (p99 $3.66, success 100.0%, sample 541)
42. goodcryptoX: $278.82 (p99 $4.36, success 100.0%, sample 1006)
43. 0x9f83…31d9: $268.98 (p99 $3.06, success 100.0%, sample 727)
44. Lootbase: $265.19 (p99 $26.52, success 100.0%, sample 62)
45. HyperX: $259.16 (p99 $2.25, success 100.0%, sample 5314)
46. Dexly Trade: $246.93 (p99 $4.26, success 100.0%, sample 561)
47. Wunder: $241.62 (p99 $1.84, success 100.0%, sample 2190)
48. Miracle: $238.26 (p99 $9.93, success 100.0%, sample 578)
49. 0xf85a…5688: $217.34 (p99 $27.17, success 100.0%, sample 120)
50. VOOI: $202.79 (p99 $15.6, success 100.0%, sample 3637)
51. Onchain.cc: $187.15 (p99 $0.5637, success 100.0%, sample 3411)
52. XBIT: $165.82 (p99 $2.67, success 100.0%, sample 278)
53. VergeX: $160.73 (p99 $1.61, success 100.0%, sample 734)
54. defi.app: $155.64 (p99 $3.99, success 100.0%, sample 325)
55. Senpi: $146.73 (p99 $2.45, success 100.0%, sample 715)
56. tuleep.trade: $124.35 (p99 $24.87, success 100.0%, sample 6774)
57. DeFi Saver: $114.79 (p99 $28.7, success 100.0%, sample 79)
58. Dexari: $113.68 (p99 $8.12, success 100.0%, sample 105)
59. 0x53a1…fcd1: $68.83 (p99 $1.72, success 100.0%, sample 206)
60. Owly.fi: $56.29 (p99 $11.26, success 100.0%, sample 962)
61. CCXT: $47.7 (p99 $0.5129, success 100.0%, sample 1905)
62. Hyprearn: $47.08 (p99 $2.77, success 100.0%, sample 385)
63. CoinPilot: $41.01 (p99 $0.4101, success 100.0%, sample 1714)
64. Arena: $35.01 (p99 $2.69, success 100.0%, sample 68)
65. UXUY: $25.64 (p99 $3.66, success 100.0%, sample 48)
66. Dextrabot: $22.1 (p99 $0.7622, success 100.0%, sample 534)
67. Wallet V: $16.78 (p99 $0.9869, success 100.0%, sample 266)
68. Gem Wallet: $14.9 (p99 $4.97, success 100.0%, sample 45)
69. Okto: $14.72 (p99 $0.6691, success 100.0%, sample 101)
70. Cwallet: $7.52 (p99 $0.8360, success 100.0%, sample 52)
71. HyperSignals: $5.78 (p99 $0.3609, success 100.0%, sample 227)
72. Liminal: $4.82 (p99 $1.61, success 100.0%, sample 65)
73. Moontrader: $3.74 (p99 $1.25, success 100.0%, sample 26)
74. Origami Tech: $3.29 (p99 $0.5477, success 100.0%, sample 857)
75. Grider: $2.58 (p99 $0.1519, success 100.0%, sample 325)
76. Lit Trade: $2.5 (p99 $0.6245, success 100.0%, sample 21)
77. Coin98: $1.88 (p99 $0.6262, success 100.0%, sample 15)
78. PerpsWLD: $1.83 (p99 $0.1831, success 100.0%, sample 43)
79. Cipher: $1.8 (p99 $0.9014, success 100.0%, sample 2)
80. GTR Trade: $1.3 (p99 $1.3, success 100.0%, sample 1)
81. Katoshi: $1.06 (p99 $0.1513, success 100.0%, sample 11)
82. KuCoin Web3: $0.8895 (p99 $0.8895, success 100.0%, sample 4)
83. SuperCEXy: $0.7152 (p99 $0.2384, success 100.0%, sample 7)
84. UnityWallet: $0.5929 (p99 $0.0371, success 100.0%, sample 105)
85. Perpmate: $0.1013 (p99 $0.1013, success 100.0%, sample 5)

**Methodology**:
- Data source. A local hl node operated on OCB infrastructure tails the Hyperliquid mainnet and writes every block of attributed fills to node_fills_by_block hourly YYYYMMDD HH on local disk. Each line is one JSON block, the events array carries one entry per fill, and every fill that opted into the builder code attribution system includes the builder address plus builderFee in USDC.
- Cadence. The Go harness re reads the current and previous hourly files every 30 seconds, parses appended lines, and updates per builder hourly buckets keyed by the UTC hour floor of the fill timestamp. Prometheus scrapes the metrics every 30 seconds via a Caddy reverse proxy with basic auth. End to end staleness from fill landing on chain to bench page render is typically under one minute.
- Headline calculation. For each builder over the last 24 rolling hours, we sum the builderFee USD values of every attributed fill. The figure is the raw amount of USDC the frontend collected through the builder code field. The 7 day and 30 day figures sum the same field over the last 168 and 720 hourly buckets respectively, so the metric is consistent across the three ranges.
- Window mechanics. The harness keeps a small in memory hourly bucket map per builder going back 30 days. Memory footprint is about 600 KB total for 104 builders. Older buckets are pruned on every publish. This is cheaper than keeping fill level granularity for 30 days and lets the bench expose the three ranges without expanding the live fill window.
- Volume companion. hl_frontend_volume_usd_24h_v2, _7d_v2 and _30d_v2 are computed the same way on the px times sz product of every fill. They feed the Volume tabs.
- Users 24h. Count of unique wallet addresses that placed at least one attributed fill on this builder in the last 24 hours. Computed on the fill level window, not the hourly buckets, because uniqueness requires the full set.
- Effective fee bps companion. Volume weighted ratio computed as sum of builder fees divided by sum of notional, times ten thousand, over the rolling 24h window. Surfaces the trader perspective on cost. Volume share dashboards rank frontends by raw notional, this column ranks them by what a representative dollar of flow paid them.
- Time since last fill. Seconds elapsed since this builder's most recent attributed fill. During active hours the cohort baseline runs under one minute, so anything above a few minutes is a real anomaly. Catches frontends whose routing pipeline is down and frontends that quietly stopped operating but still have their builder code in circulation.
- Builder registry. miniapps hyperliquid frontends local builders dot json is a hand curated array of slug, name, address and notes for every tracked frontend, currently 104 entries. New addresses ship via public PR. Builder addresses outside the registry remain visible in the raw node stream but stay off the leaderboard until added.
- Exclusions. Native Hyperliquid UI orders carry no builder code and are not user attributable by this method. Roughly 95 percent of Hyperliquid fills land without a builder field. The 5 percent that do are the frontend ecosystem this bench measures.
- Reproducibility. Harness source at miniapps hyperliquid frontends local in the mobula api repo, written in Go. Anyone running their own hl node can clone, point the data flag at their node_fills_by_block hourly root, run the binary against a Prometheus scraper, and reproduce these metrics.
- Failures. Any read error on the hourly files leaves the previous gauge values in place. Hourly bucket pruning is idempotent. Restarts replay the warmup window from disk before going live tail.

## Cheapest blockchain transaction fee, live across 14 L1 and L2 chains

- Category: Blockchains
- Metric: Native transfer fee USD (usd)
- Page: https://openchainbench.com/benchmarks/network-fees
- JSON: https://openchainbench.com/api/stat/network-fees
- Status: live
- Headline: Litecoin leads native transfer fee usd at $0.0000998 (24h) on Cheapest blockchain transaction fee, live across 14 L1 and L2 chains.

**Rankings (p50, 24h):**
1. Litecoin: $0.0000998 (p99 $0.000102, success 100.0%, sample n/a)
2. Base: $0.000238 (p99 $0.00336, success 100.0%, sample n/a)
3. Taiko: $0.000329 (p99 $0.00449, success 100.0%, sample n/a)
4. Solana: $0.000408 (p99 $0.000441, success 100.0%, sample n/a)
5. Mantle: $0.000462 (p99 $0.00460, success 100.0%, sample n/a)
6. BNB Chain: $0.000634 (p99 $0.0123, success 100.0%, sample n/a)
7. Arbitrum One: $0.000752 (p99 $0.000772, success 100.0%, sample n/a)
8. zkSync Era: $0.00170 (p99 $0.00173, success 100.0%, sample n/a)
9. Sui: $0.00563 (p99 $0.00578, success 100.0%, sample n/a)
10. Ethereum: $0.00580 (p99 $0.3385, success 100.0%, sample n/a)
11. Linea: $0.0104 (p99 $0.0454, success 100.0%, sample n/a)
12. Cardano: $0.0300 (p99 $0.0309, success 100.0%, sample n/a)
13. Monero: $0.0391 (p99 $0.1606, success 99.8%, sample n/a)
14. TRON: $0.0937 (p99 $0.0937, success 100.0%, sample n/a)

**Methodology**:
- Refresh cadence. 30 seconds. One process samples all 14 chains in parallel goroutines.
- Ethereum and BNB Chain on the L1 tab. eth_feeHistory over the last 4 blocks at percentiles 25, 50 and 90. Cost = (base_fee + reward_percentile) * 21000 gas, mapped to slow, standard and fast.
- Arbitrum, Base, zkSync Era, Linea, Mantle and Taiko on the L2 tab. Same eth_feeHistory flow against each rollup's sequencer RPC. ETH is the native gas asset on every tracked rollup except Mantle, which prices gas in MNT.
- Layer 2 caveat. The published figure is L2 execution cost only. The L1 data posting fee (blob market for EIP 4844 rollups, calldata for the rest) is excluded from this page and will be added as a separate blended figure in a later phase. On OP Stack rollups the L1 data fee can dominate the wallet visible total during expensive blob periods.
- Solana. getRecentPrioritizationFees percentiles 25, 50 and 90 of micro lamports per compute unit, times 200 compute units, plus 5000 lamports base. Empty fees response collapses to a single standard tier at the 5000 base.
- TRON. getChainParameters.getTransactionFee (currently 1000 sun per byte) times 268 bytes for a typical native transfer. Single tier because TRON native transfers do not bid into a priority market.
- Cardano. koios epoch_params.min_fee_a and min_fee_b, times 250 bytes for a typical native transfer. Deterministic by protocol, refreshes only when on chain parameters change.
- Sui. suix_getReferenceGasPrice times 76000 gas (typical observed for a Coin::transfer call). Single standard tier.
- Litecoin. litecoinspace.org /api/v1/fees/recommended (hour, half hour and fastest fees in litoshi per vByte) times 225 vBytes for a typical 1 input 1 output P2WPKH transfer.
- Monero. monero rpc get_fee_estimate.fees[0..2] times 1500 bytes for a typical 1 input 2 output RingCT transaction.
- USD prices. api.mobula.io/api/1/market/multi-data polled every 30 seconds for all 14 native tokens in one call.
- Failures. Any upstream error leaves the previous gauge in place, increments tx_fee_fetch_errors_total{chain, error_type}, and sets tx_fee_health{chain} to zero.

## Fastest prediction market data API, live freshness across venues

- Category: Aggregators
- Metric: Freshness delta vs venue (ms)
- Page: https://openchainbench.com/benchmarks/pm-data-freshness
- JSON: https://openchainbench.com/api/stat/pm-data-freshness
- Status: live
- Headline: Polymarket leads freshness delta vs venue at 1 ms (p50, 24h) on Fastest prediction market data API, live freshness across venues.

**Rankings (p50, 24h):**
1. Polymarket: 1 ms (p99 1 ms, success 100.0%, sample 238316)
2. Kalshi: 1 ms (p99 1 ms, success 99.4%, sample 3194290)
3. Mobula: 94 ms (p99 27.90 s, success 40.0%, sample 95229.6)
4. Codex: 1.17 s (p99 9.91 s, success 100.0%, sample 726915)

**Methodology**:
- Polymarket T0. `wss://ws-subscriptions-clob.polymarket.com/ws/market` is public, no auth, sub 50ms gateway publish latency from EU West. Cross correlation uses (conditionId, priceUSD rounded to 3 decimals, sizeUSD micros, 5s time bucket).
- Kalshi T0. `https://api.elections.kalshi.com/v1/social/trades` (REST), polled every 5s with cursor pagination. Every trade carries `create_date` at microsecond precision; that timestamp is the canonical T0. Poll cadence affects only correlation timing, not the freshness number. The official Kalshi WebSocket needs RSA PSS signed headers from a US KYC account and 403s from non US IPs, not viable for a public benchmark.
- Mobula PM WebSocket. `wss://pm-api-prod-eu.mobula.io`. Auth via API key in the subscribe payload. Cloudflare on the gateway requires a browser User Agent on the upgrade request, default Go HTTP UA is silently filtered. Covers Polymarket today, Kalshi coverage is not yet shipped.
- Codex GraphQL subscriptions. `wss://graph.codex.io/graphql` with the `graphql-transport-ws` subprotocol. Firehose `onPredictionTradesCreated` subscription filtered client side to the venue's marketIds. Covers both Polymarket and Kalshi.
- Basket. Top 20 active markets by 24h volume per venue, refreshed every 5 minutes. Polymarket pulls from `gamma-api.polymarket.com`, Kalshi pulls from `api.elections.kalshi.com/trade-api/v2/markets`.
- Histogram buckets: 10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000, 30000, 60000 ms. The venue's own arrivals always land in the smallest bucket because by construction we measure other providers against it.
- Region. `eu-west` (Railway europe-west4). Both venue gateways are geographically distributed; deltas reflect EU client to EU gateway latency.
- Venue clock asymmetry. Polymarket CLOB trades carry no venue timestamp so T0 is when our harness receives the WS event; the Polymarket-to-harness RTT cancels inside the Codex delta. Kalshi's REST `create_date` is venue-side so the Codex Kalshi delta includes a Codex-to-harness RTT (50 to 100 ms) the Polymarket math cancels out. Kalshi rows are slightly stricter for the same provider, not more favorable; the gap is small versus the multi-second deltas the chart highlights.

## Cheapest blockchain to deploy a token, live USD cost across 7 non-EVM L1 chains

- Category: Blockchains
- Metric: Token deployment cost USD (usd)
- Page: https://openchainbench.com/benchmarks/token-deployment-cost
- JSON: https://openchainbench.com/api/stat/token-deployment-cost
- Status: live
- Headline: Osmosis leads token deployment cost usd at $0.00121 (24h) on Cheapest blockchain to deploy a token, live USD cost across 7 non-EVM L1 chains.

**Rankings (p50, 24h):**
1. Osmosis: $0.00121 (p99 $0.00122, success 100.0%, sample n/a)
2. Aptos: $0.0952 (p99 $0.0973, success 100.0%, sample n/a)
3. Cardano: $0.2110 (p99 $0.2175, success 100.0%, sample n/a)
4. Stellar: $0.2933 (p99 $0.3039, success 100.0%, sample n/a)
5. Sui: $0.3707 (p99 $0.3801, success 100.0%, sample n/a)
6. Injective: $0.4779 (p99 $0.4962, success 100.0%, sample n/a)
7. Solana: $0.7443 (p99 $0.7557, success 100.0%, sample n/a)

**Methodology**:
- Refresh cadence. 5 minutes. One process samples all 7 chains in parallel goroutines and emits Prometheus gauges.
- Solana SPL. getMinimumBalanceForRentExemption(82) for the mint + (165) for the Associated Token Account + (679) for the Metaplex Token Metadata account + 5000 lamports per signature. Multiply by SOL USD price. Without the metadata account the headline would understate by ~2.5x.
- Sui. suix_getReferenceGasPrice times 5 million MIST gas units for a canonical coin module publish (net of storage rebate). Converted to USD via SUI price.
- Aptos. /v1/estimate_gas_price.gas_estimate octas per unit times 150000 gas units for a canonical FA standard publish. Converted to USD via APT price.
- Cosmos TokenFactory (Osmosis, Injective). LCD /<chain>/tokenfactory/v1beta1/params.denom_creation_fee. Empty array (Osmosis) means gas only, rendered as less than 0.001 dollar. Injective charges a flat 0.1 INJ.
- Cardano. Koios /epoch_params.coins_per_utxo_size. Apply Conway minUTxO formula = (160 byte overhead + 70 byte single asset bundle) × coins_per_utxo_size + 180000 lovelace mint tx fee. Converted to USD via ADA price.
- Stellar. Horizon /ledgers.base_reserve_in_stroops and base_fee_in_stroops on the latest ledger. Total cost = 3 base reserves (issuer account + distribution account + trustline on distribution) + 2 base fees (create_account + change_trust). Converted to USD via XLM price.
- USD prices. api.mobula.io/api/1/market/multi-data?symbols=SOL,SUI,APT,OSMO,INJ,ADA,XLM polled every 5 minutes.
- Failures. Any upstream error increments token_deployment_samples_total{chain,status=error} and leaves the previous gauge value in place.
- EVM chains excluded. Ethereum, BNB Chain, Avalanche, Polygon, Arbitrum, Optimism, Base, Blast, Mantle, opBNB, Celo, Scroll and Linea were previously exposed but relied on a placeholder init bytecode that undercounted real ERC20 deploy cost by 30 to 500x. Removed until the canonical OZ v5 artifact is finalised.

## Hyperliquid HIP-3 deployer revenue leaderboard

- Category: Trading
- Metric: Deployer fees collected (USD) (usd)
- Page: https://openchainbench.com/benchmarks/hyperliquid-hip3-deployers
- JSON: https://openchainbench.com/api/stat/hyperliquid-hip3-deployers
- Status: live
- Headline: trade.xyz leads deployer fees collected (usd) at $106.7K (24h) on Hyperliquid HIP-3 deployer revenue leaderboard.

**Rankings (p50, 24h):**
1. trade.xyz: $106.7K (p99 $0.1681, success 100.0%, sample 3928150)
2. HyENA: $86.86 (p99 $0.1494, success 100.0%, sample 5304)
3. Paragon: $52.64 (p99 $1.59, success 100.0%, sample 444)

**Methodology**:
- Data source. A local hl node operated on OCB infrastructure tails the Hyperliquid mainnet and writes every block of fills to node_fills_by_block hourly YYYYMMDD HH on local disk. Each line is one JSON block, the events array carries one entry per fill, and every fill on a HIP-3 market includes the dex namespaced coin (xyz:AAPL) plus the deployerFee in USDC.
- Attribution. A fill belongs to a HIP-3 dex when its coin carries a namespace prefix (xyz:AAPL belongs to xyz). Namespaces are unique on chain by construction, so no hand curated registry is needed; the harness starts tracking a new deployer with its first observed fill, and the namespace is added to this page on the next spec review. Core Hyperliquid markets carry no namespace and no deployer fee, they are excluded.
- Cadence. The Go harness re reads the current and previous hourly files every 30 seconds, parses appended lines, and updates per dex hourly buckets keyed by the UTC hour floor of the fill timestamp. Prometheus scrapes the metrics every 30 seconds via a Caddy reverse proxy with basic auth. End to end staleness from fill landing on chain to bench page render is typically under one minute.
- Headline calculation. For each dex over the last 24 rolling hours we sum the deployerFee USD values of every fill on its namespaced markets. The 7 day and 30 day figures sum the same field over the last 168 and 720 hourly buckets, so the metric is consistent across the three ranges.
- Volume companion. hl_hip3_deployer_volume_usd_24h, _7d and _30d are computed the same way on the px times sz product of every fill. They feed the Volume column and tab.
- Users. Unique wallet addresses with at least one fill on the dex. The 24h figure is a union of per hour wallet sets over the rolling window; 7d and 30d are unions of per UTC day wallet sets. After a harness restart the day sets are reseeded from the on disk fill history before the 7d and 30d gauges publish, so they never lowball.
- Markets. Count of distinct namespaced coins traded on the dex in the last 24 hours. A dex with 70 active equity markets and a dex with one commodity market are different products; the column makes that visible next to the revenue number.
- Effective fee bps. Deployer fees divided by notional volume, times ten thousand, over the rolling 24h window. The trader perspective on what a representative dollar of flow paid the dex operator.
- Window mechanics. Hourly buckets per dex go back 30 days in memory and are pruned on every publish. Per fill state is never retained; the largest dex clears about 4 million fills per day, so the bench aggregates at ingestion time instead of keeping fill level granularity.
- 30 day caveat. The node retains hourly fill files for a bounded horizon and the harness backfill reads what exists on disk. Until 30 full days of history accumulate, the 30d figures cover the available horizon and grow toward the full window.
- Naming. Every namespace is resolved against the on chain perpDexs registry, which publishes the deployer address and full name: xyz is trade.xyz, vntl is Ventuals, cash is Dreamcash, km is Markets by Kinetiq, hyna is HyENA by the Based team, flx is Felix Exchange, para is Paragon. Attribution is by namespace prefix either way, so the numbers do not depend on naming.
- Reproducibility. Harness source is open in the OCB harness tree. Anyone running their own hl node can clone, point the data flag at their node_fills_by_block hourly root, run the binary against a Prometheus scraper, and reproduce these metrics.
- Failures. Any read error on the hourly files leaves the previous gauge values in place. Hourly bucket pruning is idempotent. Restarts replay the warmup window from disk before going live tail, and reseed the user sets from history in the background.

## Cheapest perp venue to hold a position, live funding normalized

- Category: Trading
- Metric: Funding cost to hold a long 24h (bp)
- Page: https://openchainbench.com/benchmarks/perp-funding
- JSON: https://openchainbench.com/api/stat/perp-funding
- Status: live
- Headline: Bybit leads funding cost to hold a long 24h at 1.14 bps (p50, 24h) on Cheapest perp venue to hold a position, live funding normalized.

**Rankings (p50, 24h):**
1. Bybit: 1.14 bps (p99 1.82 bps, success 100.0%, sample 3)
2. Binance: 1.45 bps (p99 0.67 bps, success 100.0%, sample 3)
3. OKX: 1.52 bps (p99 0.42 bps, success 100.0%, sample 3)
4. Aster: 1.95 bps (p99 1.43 bps, success 100.0%, sample 3)
5. Paradex: 2.86 bps (p99 1.30 bps, success 100.0%, sample 3)
6. Hyperliquid: 3.00 bps (p99 2.92 bps, success 100.0%, sample 3)

**Methodology**:
- Sources. One public, unauthenticated endpoint per venue: Hyperliquid info metaAndAssetCtxs (live 1h rate), Binance fapi premiumIndex plus fundingInfo for per pair intervals, Bybit v5 tickers plus instruments-info (interval in minutes), OKX public funding-rate (interval from settlement timestamps), dYdX v4 indexer perpetualMarkets (per hour rate), Paradex markets summary (8h period), Aster premiumIndex (Binance compatible).
- Normalization. Every venue quotes a rate for its own settlement period. The harness divides the quoted rate by the venue's interval in hours to get a per hour rate, then publishes per hour bps (rate times 10000), 24 hour hold cost (per hour times 24) and annualized percent (per hour times 24 times 365 times 100). A 0.01 percent per 8h rate and a 0.00125 percent per 1h rate are the same number on this page.
- Sign convention. Positive means longs pay shorts, negative means longs are paid to hold. Signs are preserved through every column; the ranking treats negative as cheaper, so a venue where the long side is being paid ranks first.
- Headline. Cost in bps of notional to hold an ETH long for 24 hours, averaged over the last 24 hours of one minute samples. The instantaneous rate moves every settlement; the 24 hour average is what a position opened yesterday actually paid. BTC and SOL columns are computed identically.
- Windows. The 7 day and 30 day columns are avg_over_time of the normalized hold cost series, the carry trader's view. A venue with attractive funding for one hour and brutal funding the rest of the week ranks accordingly on the longer windows.
- Cadence. The harness polls all venues in parallel every 60 seconds with a 10 second timeout per request; Prometheus scrapes every 30 seconds. End to end staleness is under two minutes in normal operation.
- Failures. A venue that errors or times out keeps its previous gauge values and its perp_funding_venue_ok_unix timestamp stops advancing; the Success column turns red after 5 minutes of silence. No value on this page is ever interpolated or guessed.
- Scope. BTC, ETH and SOL are the assets every venue in the cohort lists. GMX is excluded because its borrow fee model has no comparable funding rate. Lighter is excluded until the interval semantics of its public funding endpoint are documented; it joins the cohort once its numbers can be normalized honestly.
- Funding versus fees. This bench prices holding. Its companion perp-fees prices opening (taker fee plus spread plus impact on a $1000 ETH long). Read both to know the all in cost of a trade you intend to hold.
- Reproducibility. The harness source is open in the OCB harness tree (funding.go in the hyperliquid-frontends harness). Point it at the same public endpoints and you reproduce every number on this page.

## Prediction market API rate limits, tested with a daily ramp

- Category: Trading
- Metric: Warm book latency (ms)
- Page: https://openchainbench.com/benchmarks/pm-rate-limits
- JSON: https://openchainbench.com/api/stat/pm-rate-limits
- Status: live
- Headline: Limitless leads warm book latency at 97 ms (p50, 24h) on Prediction market API rate limits, tested with a daily ramp.

**Rankings (p50, 24h):**
1. Limitless: 97 ms (p99 914 ms, success 100.0%, sample 51836.3)
2. Polymarket: 201 ms (p99 327 ms, success 100.0%, sample 51840.1)
3. Kalshi: 287 ms (p99 543 ms, success 100.0%, sample 51838.3)
4. Myriad: 1.83 s (p99 3.90 s, success 100.0%, sample 51831.3)

**Methodology**:
- Endpoint classes per venue. Polymarket: CLOB `/book`, `/midpoint`, Gamma `/markets`. Kalshi: `/markets/{ticker}/orderbook`, `/markets/{ticker}`, `/markets`. Limitless: `/markets/{slug}/orderbook`, `/markets/{slug}`, `/markets/active`. Manifold: `/v0/bets`, `/v0/market/{id}`, `/v0/markets`. Myriad: `/markets/{slug}`, `/markets`. Myriad exposes no order book endpoint; that absence is reported, not worked around.
- Pinned market per venue: most liquid, near the money (price between 0.15 and 0.85), expiring more than 24h out. Re pinned daily at 00:00 UTC and immediately on probe_invalid. A degenerate 0.99 book has a latency profile that does not represent real usage.
- Warm probes every 5s (7s on Manifold, whose entire API sits behind max-age=5 plus stale-while-revalidate=10; tighter spacing would only measure the cache). Cold connect probe once per minute with keep alives disabled, TCP plus TLS handshake recorded separately.
- Every sample records a cache flag from cf-cache-status, x-cache and age headers. Kalshi's market list is served from CloudFront with max-age=15, so its list latency measures the edge, not the API. Edge served samples (cache=hit) are excluded from every latency aggregate and reported through the cache label, so no venue ranks on its CDN.
- Outcome classification: ok, timeout (8s), http_4xx, http_5xx, throttled (429), probe_invalid, net_error. Latency aggregates include successful requests only; failures count toward the success rate. probe_invalid covers stale pins, e.g. Limitless serves a CDN cached 400 for four hours once a market expires. Those are our fault, never the venue's.
- Daily ramp: 60s per tier at rising requests per 10s window against the book endpoint, one venue at a time, one region at a time on disjoint UTC hours (02:00 us-east, 04:00 eu-west, 06:00 sgp).
- Ramp tier clamps: Polymarket and Kalshi 25/50/100 per 10s (at most 7 percent of Polymarket's documented 1500 per 10s book budget), Manifold 15/30/60 (500 req/min per IP documented), Limitless 10/20/40 (limits undocumented, so conservative). Kalshi stops at the first 429 since its token bucket is documented. Myriad is excluded: its keyless budget is 30 req per 10s and ramping it would only measure our own quota.
- Ramp abort guard: the run stops the moment throttled plus 5xx responses exceed 1 percent of any 10 second window. The headline ramp metric is p50 latency during the tier minus the warm baseline p50 of the previous hour in the same region, because venues behind Cloudflare queue bursts without ever returning 429, and added latency is the only honest throttle signal there.
- WebSocket panel covers venues with a public market WebSocket, which today means Polymarket only. Kalshi requires authentication for WS, Manifold and Myriad have none, Limitless uses socket.io. Absence is shown, not penalized.
- Myriad's origin is a single region US East deployment behind Heroku. Latency from eu-west and sgp is geography, reported as measured.
- All probes hit documented public developer APIs with the identifying User-Agent `OpenChainBench/1.0 (+https://openchainbench.com/methodology; contact@mobula.io)`. We publish latency measurements only, never order book contents or prices, in line with venue data redistribution terms (Kalshi's in particular, applied to all venues equally).
- Regions: us-east, eu-west, sgp (Railway). Histogram buckets 25ms to 10s.

## Best prediction market API, ranked by live latency and uptime

- Category: Trading
- Metric: API latency (price endpoint) (ms)
- Page: https://openchainbench.com/benchmarks/pm-api-latency
- JSON: https://openchainbench.com/api/stat/pm-api-latency
- Status: live
- Headline: Limitless leads api latency (price endpoint) at 113 ms (p50, 24h) on Best prediction market API, ranked by live latency and uptime.

**Rankings (p50, 24h):**
1. Limitless: 113 ms (p99 740 ms, success 100.0%, sample 51839.1)
2. Polymarket: 201 ms (p99 293 ms, success 100.0%, sample 51839.1)
3. Kalshi: 297 ms (p99 535 ms, success 100.0%, sample 51840.1)
4. Myriad: 1.83 s (p99 3.90 s, success 100.0%, sample 51833.1)

**Methodology**:
- Price endpoint per venue. Polymarket: CLOB `/midpoint`. Kalshi: `/markets/{ticker}`. Limitless: `/markets/{slug}`. Manifold: `/v0/market/{id}`. Myriad: `/markets/{slug}`. This is the hot path of real integrations: one market, one quote, polled in a loop.
- Warm probes every 5s (7s on Manifold, whose API sits behind max-age=5 plus stale-while-revalidate=10) from us-east, eu-west and sgp over a keep alive pool. A separate cold connect probe once per minute records the TCP plus TLS handshake a brand new client pays.
- Every sample carries a cache flag read from cf-cache-status, x-cache and age headers. Latency aggregates exclude cache hits: a CDN hit measures the nearest edge, not the venue's API, and including Manifold's residual cache hits would flatter it by design.
- Uptime is the average of a per venue, per region health gauge (pmapi_health) computed by the harness from probe outcomes. 100 percent means every probe cycle in the window succeeded from that region. The 24h and 7d panels below are the live answer to whether each API is up.
- Outcome classification: ok, timeout (8s), http_4xx, http_5xx, throttled, probe_invalid, net_error. probe_invalid covers failures that are our pin's fault, such as a market that resolved intraday; those are excluded from both latency and uptime. The pinned market is re selected daily at 00:00 UTC and immediately on probe_invalid.
- Division of labor with the sibling benches: how each venue behaves as request rates climb, including throttle onset and 429 handling, is measured in pm-rate-limits (bench 037). How fresh third party data providers relay Polymarket data is measured in pm-data-freshness (bench 032). This bench ranks the venues' own APIs on latency and uptime at a polite request rate.
- Myriad's origin is a single region US East deployment behind Heroku, so its latency from eu-west and sgp is dominated by geography. Reported as measured, called out per region.
- All five venues are probed by the same open source harness as bench 037, from the same processes, so the two benches share one probe budget and one identifying User-Agent: `OpenChainBench/1.0 (+https://openchainbench.com/methodology; contact@mobula.io)`. We publish latency and uptime measurements only, never market data.
- Aggregators that resell venue data (Mobula, Codex, Predexon) are deliberately excluded from this leaderboard. They are not venue APIs, they are relays on top of venue APIs, and ranking them next to the venues they relay would compare two different products on one axis. Their freshness lag against the Polymarket CLOB T0 stream is the relevant metric, measured in the pm-data-freshness bench. The prediction markets hub data feeds tab lists each aggregator with the venues it covers.
- Regions: us-east, eu-west, sgp (Railway). Histogram buckets 25ms to 10s.

## Polymarket resolution time, measured onchain

- Category: Trading
- Metric: Resolution delay (s)
- Page: https://openchainbench.com/benchmarks/polymarket-resolution-delay
- JSON: https://openchainbench.com/api/stat/polymarket-resolution-delay
- Status: live
- Headline: Crypto leads resolution delay at 11.2 min (p50, 24h) on Polymarket resolution time, measured onchain.

**Rankings (p50, 24h):**
1. Crypto: 11.2 min (p99 163.7 min, success 100.0%, sample 16016)
2. Other: 24.9 min (p99 237.9 min, success 100.0%, sample 29347)
3. All markets: 37.9 min (p99 237.5 min, success 100.0%, sample 131801)
4. Sports: 46.3 min (p99 238.1 min, success 100.0%, sample 85730)
5. Politics: 180.6 min (p99 440.2 min, success 100.0%, sample 708)

**Methodology**:
- Anchor: the first OO ProposePrice block timestamp, not Gamma fields. Verified live: Gamma closedTime equals the QuestionResolved block timestamp to the second (circular by construction) and endDate is a scheduled buffer that a majority of markets resolve before. Any 'resolves within X' claim computed from those fields is unfalsifiable.
- Sources: Polygon logs of the post-migration UMA CTF adapters (binary 0x65070BE9..., neg-risk 0x69c47De9...) and their Optimistic Oracle (0x2c0367a9...), all address-configurable. Gamma supplies the market catalogue and category tags.
- Join: questionID = keccak256 of the proposal ancillary data, verified against QuestionInitialized events. Neg-risk markets expose a different Gamma questionID; categories fall back to keyword classification for those, the delay itself is unaffected.
- Categories: sports, politics, crypto, other, classified from Gamma tags plus keyword fallback. Categories run different UMA verification windows, so per category rows are the honest unit of comparison.
- Disputes: a DisputePrice before resolution marks the market disputed and its delay lands in the disputed series. QuestionReset events are tracked so re-proposals do not create duplicate joins.
- Pending backlog: markets past their scheduled endDate with no onchain resolution, polled from Gamma every cycle. This includes markets whose underlying event has not happened yet despite the date passing, so it is an upper bound.
- Listener: 45s incremental Polygon log polling with a 7 day chunked backfill on restart, two public RPC endpoints with rotation and backoff. Counters re-count the backfill window after a restart; quantiles are computed on the cumulative histogram, which the backfill repopulates within minutes.
- Delays are measured between block timestamps, so the resolution granularity is Polygon's block time (~2s), negligible against delays measured in minutes and hours.
- What this does not measure: the gap between the real world event ending and someone submitting the first proposal. That interval is not observable onchain; the proposal is the first onchain signal that the outcome is known. Reported delays are therefore a lower bound on the total wait.

## Best NFT collection metadata API: Moralis, Alchemy, OpenSea benchmarked

- Category: NFT APIs
- Metric: Field coverage (pct)
- Page: https://openchainbench.com/benchmarks/nft-collection-metadata
- JSON: https://openchainbench.com/api/stat/nft-collection-metadata
- Status: live
- Headline: Moralis leads field coverage at 96.5% (24h avg) on Best NFT collection metadata API: Moralis, Alchemy, OpenSea benchmarked.

**Rankings (p50, 24h):**
1. Moralis: 96.5% (p99 96.5%, success 100.0%, sample 980.17)
2. OpenSea: 96.0% (p99 96.0%, success 100.0%, sample 1000.17)
3. Alchemy: 76.4% (p99 76.4%, success 100.0%, sample 1000.17)

**Methodology**:
- Collection set: a fixed list of 50 Ethereum blue-chip collections (BAYC, CryptoPunks, Azuki, Pudgy Penguins, Doodles, MAYC, Moonbirds, CloneX, Otherdeeds, Meebits and others). The list is committed to the harness repo and only changes via PR.
- Fields scored (5): `name`, `image`, `description`, `floor_eth`, `external_url`. A field counts as covered if the provider returns a non-empty string or a positive number.
- Apple-to-apple: each provider gets exactly one chance per field. No OR-of-multiple-URLs tricks.
- Providers in scope: Moralis (`/nft/{address}/metadata`), Alchemy (`getContractMetadata`), OpenSea (`/api/v2/collections/{slug}` plus `/api/v2/collections/{slug}/stats` for floor; slug pre-resolved via `/api/v2/chain/ethereum/contract/{addr}`, so OpenSea costs two API calls per collection per check).
- Cadence: every 6 hours per provider × collection. Steady-state ≈ 200 checks per provider per day, ~1000 field checks per provider per day.
- Region: `eu-west` (single point. multi-region requires running additional monitor instances).
- Ratio: `nft_metadata_success_total / nft_metadata_checks_total`, expressed in percent. Failures of the metadata API itself (timeouts, 5xx) are not counted in the denominator. only successful responses with the field check applied.

## Perp DEX volume share, live 24h notional ranked

- Category: Trading
- Metric: 24h perp volume (usd)
- Page: https://openchainbench.com/benchmarks/perp-volume-share
- JSON: https://openchainbench.com/api/stat/perp-volume-share
- Status: live
- Headline: Hyperliquid leads 24h perp volume at $5.04B (24h) on Perp DEX volume share, live 24h notional ranked.

**Rankings (p50, 24h):**
1. Hyperliquid: $5.04B (p99 $5.55B, success 66.7%, sample 5759)
2. Aster: $1.86B (p99 $2.00B, success 66.7%, sample 5759)
3. Lighter: $1.42B (p99 $1.54B, success 66.7%, sample 5759)
4. GRVT: $1.32B (p99 $1.38B, success 66.6%, sample 5759)
5. Pacifica: $818.16M (p99 $887.78M, success 66.7%, sample 5759)
6. Extended: $582.16M (p99 $648.31M, success 66.4%, sample 5759)
7. dYdX v4: $80.77M (p99 $96.17M, success 66.7%, sample 5759)
8. Vertex: $52.54M (p99 $122.13M, success 100.0%, sample 5759)
9. Paradex: $9.17M (p99 $10.12M, success 66.7%, sample 5759)
10. Aevo: $287.3K (p99 $731.1K, success 66.7%, sample 5759)

**Methodology**:
- Cadence: every 5 minutes per venue in parallel, 10 second timeout per request.
- Hyperliquid: info dayNtlVlm summed across all assets, published as the trailing 24 hour taker notional in USD.
- Aster: fapi 24h ticker per instrument, quoteVolume summed across all USDT perps.
- Lighter: public stats endpoint, 24h volume per market summed across markets in USD.
- GRVT: public markets endpoint, 24h volume per instrument summed in USD.
- Extended: public markets API, 24h volume per instrument summed in USD.
- Pacifica: onchain reads on the Solana program state for trailing 24h taker notional.
- Vertex: public indexer, 24h volume per product summed across all perps.
- dYdX v4: indexer perpetualMarkets, volume24H summed across markets in USD.
- Aevo: public markets endpoint, 24h volume per instrument summed in USD.
- Paradex: markets summary on Starknet L2, 24h volume summed across perps.
- Headline. avg_over_time of the 24 hour volume gauge over the last 24 hours, so a one-print spike does not move the ranking. The Series tab plots the raw gauge.
- Failures. A venue that errors or times out keeps its last gauge value and its perp_venue_health gauge drops toward 0; the leaderboard tags it as stale.

## Perp DEX open interest, live USD notional ranked

- Category: Trading
- Metric: Open interest (usd)
- Page: https://openchainbench.com/benchmarks/perp-open-interest
- JSON: https://openchainbench.com/api/stat/perp-open-interest
- Status: live
- Headline: Hyperliquid leads open interest at $7.41B (24h) on Perp DEX open interest, live USD notional ranked.

**Rankings (p50, 24h):**
1. Hyperliquid: $7.41B (p99 $7.58B, success 66.7%, sample 5759)
2. Aster: $927.99M (p99 $936.21M, success 66.7%, sample 5759)
3. Lighter: $408.54M (p99 $422.93M, success 66.7%, sample 5759)
4. GRVT: $359.56M (p99 $365.43M, success 66.6%, sample 5759)
5. Extended: $204.60M (p99 $209.78M, success 66.4%, sample 5759)
6. Pacifica: $88.14M (p99 $89.32M, success 66.7%, sample 5759)
7. Ostium: $87.75M (p99 $90.12M, success 40.0%, sample 5759)
8. Vertex: $64.38M (p99 $68.38M, success 100.0%, sample 5759)
9. dYdX v4: $47.80M (p99 $49.82M, success 66.7%, sample 5759)
10. Paradex: $9.59M (p99 $9.85M, success 66.7%, sample 5759)
11. Aevo: $9.41M (p99 $9.57M, success 66.7%, sample 5759)
12. gains.trade: $3.73M (p99 $4.30M, success 40.0%, sample 5759)

**Methodology**:
- Cadence: every 5 minutes per venue in parallel, 10 second timeout per request.
- Hyperliquid: info metaAndAssetCtxs, openInterest summed across all assets and priced in USD using the venue's own mark price.
- Aster: fapi openInterest endpoint per instrument, summed across all listed USDT perps.
- Lighter: orderBookDetails per market, open interest summed across markets in USD.
- GRVT: public markets endpoint, open interest per instrument summed in USD.
- Extended: public markets API, open interest per instrument summed in USD.
- Ostium: subgraph read for open interest across all listed pairs on Arbitrum.
- Pacifica: onchain reads on the Solana program state for aggregate open interest.
- Vertex: public indexer, open interest per product summed across all perps.
- dYdX v4: indexer perpetualMarkets, openInterest per market summed in USD.
- Aevo: public markets endpoint, open interest per instrument summed in USD.
- Paradex: markets summary endpoint on Starknet L2, open interest summed across perps.
- gains.trade: trading-variables endpoint per chain backend (Arbitrum, Base, Polygon, ApeChain), per-collateral pairOis summed then multiplied by collateralPriceUsd, summed across all chains.
- Headline. avg_over_time of the live OI gauge over the last 24 hours, so a one-print spike does not move the ranking. The Series tab plots the raw gauge.
- Failures. A venue that errors or times out keeps its last gauge value and its perp_venue_health gauge drops toward 0; the leaderboard tags it as stale.

## Perp DEX funding stability, 24h stddev of ETH funding ranked

- Category: Trading
- Metric: 24h ETH funding stddev (bps)
- Page: https://openchainbench.com/benchmarks/perp-funding-stability
- JSON: https://openchainbench.com/api/stat/perp-funding-stability
- Status: live
- Headline: Paradex leads 24h eth funding stddev at 0.0016% (24h avg) on Perp DEX funding stability, 24h stddev of ETH funding ranked.

**Rankings (p50, 24h):**
1. Paradex: 0.0016% (p99 0.0089%, success 100.0%, sample 2880)
2. Coinbase: 0.0024% (p99 0.0097%, success 100.0%, sample 5759)
3. Bitget: 0.0042% (p99 0.0069%, success 100.0%, sample 5759)
4. Gate: 0.0045% (p99 0.0052%, success 100.0%, sample 5759)
5. MEXC: 0.0059% (p99 0.0099%, success 100.0%, sample 5759)
6. Aster: 0.0078% (p99 0.014%, success 100.0%, sample 2880)
7. Binance: 0.0079% (p99 0.016%, success 100.0%, sample 2880)
8. KuCoin: 0.0084% (p99 0.0081%, success 100.0%, sample 5759)
9. OKX: 0.0091% (p99 0.0082%, success 100.0%, sample 2880)
10. Bybit: 0.015% (p99 0.015%, success 100.0%, sample 2880)
11. Kraken: 0.048% (p99 0.049%, success 100.0%, sample 5759)
12. dYdX v4: 0.056% (p99 0.046%, success 100.0%, sample 2880)

**Methodology**:
- Source. Same upstream as perp-funding: each venue's public funding endpoint polled every 60 seconds, normalized to bps per hour and per 24h hold, sign preserved.
- Metric. stddev_over_time(perp_funding_hold_24h_bps{asset="ETH"}[24h]) per venue. The 7d window smooths intraday noise but reacts to regime shifts within a week.
- Sign handling. The underlying series is signed (positive means longs pay). Stability measures the swing, so the ranking uses the unsigned stddev. Average direction and level are the perp-funding bench.
- Cohort. 15 venues across two sources. 7 polled directly (perp_funding_hold_24h_bps): Hyperliquid, Bybit, dYdX v4, Binance, OKX, Paradex, Aster. 8 via Mobula CEFI aggregator (perp_venue_funding_24h_bps): Bitget, Coinbase, Deribit, Gate, Kraken, KuCoin, Lighter, MEXC. Both normalize to bps per 24h hold, sign preserved, so the unsigned stddev compares cleanly across the full cohort.
- Success. Same freshness signal as perp-funding: perp_funding_venue_ok_unix advancing within the last 5 minutes. A venue whose scrape stalls is tagged stale on the row.
- Cadence. The upstream funding harness polls every 60 seconds; Prometheus scrapes every 30 seconds. The 7 day stddev refreshes on every scrape.
- Failures. A venue whose upstream funding feed errors keeps its last gauge value; the leaderboard tags the row stale once the success gauge drops to 0.
- Reproducibility. The harness emits perp_funding_hold_24h_bps with labels venue and asset; the bench query is the stddev over 7d on that series with asset=ETH pinned.

## Fastest free Ethereum RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/ethereum-rpc
- JSON: https://openchainbench.com/api/stat/ethereum-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 130 ms (p50, 24h) on Fastest free Ethereum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 130 ms (p99 6.28 s, success 99.6%, sample 8633.94)
2. dRPC: 176 ms (p99 479 ms, success 85.8%, sample 8636.82)
3. Nodies: 187 ms (p99 294 ms, success 100.0%, sample 8639.82)
4. Tenderly: 240 ms (p99 618 ms, success 100.0%, sample 8639.82)
5. MeowRPC: 281 ms (p99 618 ms, success 99.5%, sample 8635.82)
6. Lava: 365 ms (p99 2.63 s, success 99.0%, sample 8639.82)
7. Flashbots: 688 ms (p99 970 ms, success 100.0%, sample 8640.82)
8. 1RPC: 1.42 s (p99 5.30 s, success 0.7%, sample 8638.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="ethereum". Provider coverage: 9 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Nodies, Lava, MeowRPC, Flashbots, Cloudflare). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Arbitrum RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/arbitrum-rpc
- JSON: https://openchainbench.com/api/stat/arbitrum-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 97 ms (p50, 24h) on Fastest free Arbitrum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 97 ms (p99 696 ms, success 100.0%, sample 8637.82)
2. Nodies: 182 ms (p99 304 ms, success 99.7%, sample 8636.82)
3. Tenderly: 239 ms (p99 261 ms, success 100.0%, sample 8634.82)
4. Arbitrum: 247 ms (p99 351 ms, success 100.0%, sample 8640.82)
5. dRPC: 258 ms (p99 840 ms, success 85.2%, sample 8638.82)
6. MeowRPC: 281 ms (p99 445 ms, success 98.2%, sample 8639.82)
7. Lava: 402 ms (p99 2.42 s, success 99.5%, sample 8633.82)
8. 1RPC: 951 ms (p99 4.86 s, success 0.6%, sample 8636.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="arbitrum". Provider coverage: 8 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Nodies, Lava, MeowRPC, Arbitrum). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Base RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/base-rpc
- JSON: https://openchainbench.com/api/stat/base-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 156 ms (p50, 24h) on Fastest free Base RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 156 ms (p99 1.61 s, success 99.8%, sample 8635.88)
2. dRPC: 222 ms (p99 895 ms, success 51.1%, sample 8639.9)
3. Merkle: 242 ms (p99 574 ms, success 81.9%, sample 8638.32)
4. Tenderly: 247 ms (p99 748 ms, success 100.0%, sample 8638.82)
5. Base: 262 ms (p99 1.27 s, success 100.0%, sample 8638.82)
6. Nodies: 272 ms (p99 400 ms, success 100.0%, sample 8638.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="base". Provider coverage: 6 no-key endpoints (PublicNode, dRPC, Tenderly, Nodies, Merkle, Base). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Optimism RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/optimism-rpc
- JSON: https://openchainbench.com/api/stat/optimism-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 89 ms (p50, 24h) on Fastest free Optimism RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 89 ms (p99 472 ms, success 100.0%, sample 8636.82)
2. dRPC: 171 ms (p99 277 ms, success 73.4%, sample 8640.82)
3. Nodies: 191 ms (p99 366 ms, success 100.0%, sample 8638.82)
4. Tenderly: 240 ms (p99 262 ms, success 100.0%, sample 8639.82)
5. Optimism: 330 ms (p99 351 ms, success 99.9%, sample 8640.82)
6. 1RPC: 1.43 s (p99 3.85 s, success 0.6%, sample 8636.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="optimism". Provider coverage: 6 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Nodies, Optimism). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Avalanche RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/avalanche-rpc
- JSON: https://openchainbench.com/api/stat/avalanche-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 96 ms (p50, 24h) on Fastest free Avalanche RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 96 ms (p99 521 ms, success 100.0%, sample 8637.82)
2. dRPC: 173 ms (p99 255 ms, success 85.5%, sample 8639.82)
3. Avalanche: 198 ms (p99 278 ms, success 100.0%, sample 8639.82)
4. Tenderly: 329 ms (p99 398 ms, success 100.0%, sample 8640.82)
5. 1RPC: 655 ms (p99 2.17 s, success 0.7%, sample 8636.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="avalanche". Provider coverage: 6 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Nodies, Avalanche). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free BNB Chain RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/bnb-rpc
- JSON: https://openchainbench.com/api/stat/bnb-rpc
- Status: live
- Headline: dRPC leads rpc latency at 21 ms (p50, 24h) on Fastest free BNB Chain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 21 ms (p99 175 ms, success 25.1%, sample 8638.82)
2. Binance: 72 ms (p99 82 ms, success 100.0%, sample 8640.82)
3. Nodies: 180 ms (p99 226 ms, success 100.0%, sample 8637.82)
4. PublicNode: 186 ms (p99 363 ms, success 100.0%, sample 8638.82)
5. Merkle: 242 ms (p99 587 ms, success 81.6%, sample 8639.18)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="bnb". Provider coverage: 5 no-key endpoints (PublicNode, dRPC, Nodies, Merkle, Binance). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Polygon RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/polygon-rpc
- JSON: https://openchainbench.com/api/stat/polygon-rpc
- Status: live
- Headline: dRPC leads rpc latency at 83 ms (p50, 24h) on Fastest free Polygon RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 83 ms (p99 1.13 s, success 100.0%, sample 8634.82)
2. PublicNode: 107 ms (p99 5.09 s, success 99.0%, sample 8634.88)
3. Nodies: 183 ms (p99 221 ms, success 100.0%, sample 8640.82)
4. Tenderly: 333 ms (p99 1.75 s, success 98.7%, sample 8626.82)
5. 1RPC: 568 ms (p99 2.59 s, success 0.7%, sample 8635.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="polygon". Provider coverage: 5 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Nodies). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Linea RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/linea-rpc
- JSON: https://openchainbench.com/api/stat/linea-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 92 ms (p50, 24h) on Fastest free Linea RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 92 ms (p99 408 ms, success 100.0%, sample 8638.82)
2. dRPC: 187 ms (p99 424 ms, success 85.8%, sample 8639.82)
3. Tenderly: 326 ms (p99 405 ms, success 100.0%, sample 8640.82)
4. 1RPC: 612 ms (p99 4.59 s, success 0.6%, sample 8636.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="linea". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Scroll RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/scroll-rpc
- JSON: https://openchainbench.com/api/stat/scroll-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 95 ms (p50, 24h) on Fastest free Scroll RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 95 ms (p99 500 ms, success 100.0%, sample 8637.82)
2. dRPC: 212 ms (p99 499 ms, success 85.9%, sample 8640.82)
3. Tenderly: 326 ms (p99 411 ms, success 100.0%, sample 8640.82)
4. 1RPC: 1.04 s (p99 4.85 s, success 0.6%, sample 8637.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="scroll". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Mantle RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/mantle-rpc
- JSON: https://openchainbench.com/api/stat/mantle-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 111 ms (p50, 24h) on Fastest free Mantle RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 111 ms (p99 584 ms, success 100.0%, sample 8640.82)
2. Tenderly: 328 ms (p99 366 ms, success 100.0%, sample 8639.82)
3. dRPC: 415 ms (p99 750 ms, success 85.8%, sample 8637.82)
4. 1RPC: 1.20 s (p99 2.29 s, success 0.0%, sample 8638.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="mantle". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Sonic RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/sonic-rpc
- JSON: https://openchainbench.com/api/stat/sonic-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 95 ms (p50, 24h) on Fastest free Sonic RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 95 ms (p99 451 ms, success 100.0%, sample 8634.82)
2. dRPC: 182 ms (p99 277 ms, success 85.8%, sample 8639.82)
3. Sonic Labs: 241 ms (p99 496 ms, success 100.0%, sample 8640.82)
4. Tenderly: 327 ms (p99 351 ms, success 100.0%, sample 8636.82)
5. Lava: 385 ms (p99 2.45 s, success 99.6%, sample 8638.82)
6. 1RPC: 999 ms (p99 2.62 s, success 0.4%, sample 8638.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="sonic". Provider coverage: 6 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Lava, Sonic Labs). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Gnosis RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/gnosis-rpc
- JSON: https://openchainbench.com/api/stat/gnosis-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 96 ms (p50, 24h) on Fastest free Gnosis RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 96 ms (p99 566 ms, success 100.0%, sample 8638.82)
2. dRPC: 181 ms (p99 258 ms, success 85.4%, sample 8640.82)
3. Tenderly: 416 ms (p99 550 ms, success 100.0%, sample 8639.82)
4. Gnosis: 433 ms (p99 2.00 s, success 100.0%, sample 8635.82)
5. 1RPC: 689 ms (p99 4.79 s, success 0.6%, sample 8638.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="gnosis". Provider coverage: 6 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Nodies, Gnosis). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Celo RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/celo-rpc
- JSON: https://openchainbench.com/api/stat/celo-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 118 ms (p50, 24h) on Fastest free Celo RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 118 ms (p99 468 ms, success 100.0%, sample 8638.82)
2. Celo (Forno): 203 ms (p99 255 ms, success 100.0%, sample 8638.82)
3. dRPC: 241 ms (p99 999 ms, success 86.5%, sample 8638.82)
4. Tenderly: 327 ms (p99 388 ms, success 100.0%, sample 8639.82)
5. 1RPC: 2.75 s (p99 4.50 s, success 0.6%, sample 8637.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="celo". Provider coverage: 5 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Celo (Forno)). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Moonbeam RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/moonbeam-rpc
- JSON: https://openchainbench.com/api/stat/moonbeam-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 166 ms (p50, 24h) on Fastest free Moonbeam RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 166 ms (p99 641 ms, success 100.0%, sample 8634.82)
2. Moonbeam: 225 ms (p99 750 ms, success 100.0%, sample 8637.82)
3. dRPC: 235 ms (p99 898 ms, success 83.3%, sample 8640.82)
4. Tenderly: 328 ms (p99 365 ms, success 100.0%, sample 8636.82)
5. 1RPC: 1.88 s (p99 5.46 s, success 0.5%, sample 8637.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="moonbeam". Provider coverage: 5 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Moonbeam). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Unichain RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/unichain-rpc
- JSON: https://openchainbench.com/api/stat/unichain-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 118 ms (p50, 24h) on Fastest free Unichain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 118 ms (p99 497 ms, success 100.0%, sample 8639.82)
2. dRPC: 173 ms (p99 259 ms, success 85.8%, sample 8636.82)
3. Unichain: 245 ms (p99 348 ms, success 100.0%, sample 8638.82)
4. Tenderly: 336 ms (p99 360 ms, success 100.0%, sample 8639.82)
5. 1RPC: 1.22 s (p99 4.63 s, success 0.5%, sample 8637.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="unichain". Provider coverage: 5 no-key endpoints (PublicNode, dRPC, 1RPC, Tenderly, Unichain). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Blast RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/blast-rpc
- JSON: https://openchainbench.com/api/stat/blast-rpc
- Status: live
- Headline: Blast leads rpc latency at 1 ms (p50, 24h) on Fastest free Blast RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Blast: 1 ms (p99 4 ms, success 100.0%, sample 8639.82)
2. PublicNode: 92 ms (p99 467 ms, success 100.0%, sample 8634.82)
3. dRPC: 232 ms (p99 570 ms, success 85.9%, sample 8638.82)
4. Tenderly: 327 ms (p99 365 ms, success 100.0%, sample 8640.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="blast". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Blast). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Taiko RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/taiko-rpc
- JSON: https://openchainbench.com/api/stat/taiko-rpc
- Status: live
- Headline: PublicNode leads rpc latency at 210 ms (p50, 24h) on Fastest free Taiko RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 210 ms (p99 630 ms, success 100.0%, sample 8638.82)
2. Taiko: 210 ms (p99 671 ms, success 99.9%, sample 8632.82)
3. dRPC: 259 ms (p99 1.50 s, success 80.5%, sample 8637.82)
4. Tenderly: 325 ms (p99 346 ms, success 100.0%, sample 8639.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="taiko". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Taiko). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Berachain RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/berachain-rpc
- JSON: https://openchainbench.com/api/stat/berachain-rpc
- Status: live
- Headline: Berachain leads rpc latency at 158 ms (p50, 24h) on Fastest free Berachain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Berachain: 158 ms (p99 170 ms, success 100.0%, sample 8638.82)
2. PublicNode: 199 ms (p99 595 ms, success 100.0%, sample 8636.82)
3. dRPC: 262 ms (p99 1.48 s, success 85.9%, sample 8636.82)
4. Tenderly: 325 ms (p99 360 ms, success 100.0%, sample 8639.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="berachain". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Berachain). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free zkSync Era RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/zksync-rpc
- JSON: https://openchainbench.com/api/stat/zksync-rpc
- Status: live
- Headline: dRPC leads rpc latency at 179 ms (p50, 24h) on Fastest free zkSync Era RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 179 ms (p99 334 ms, success 86.2%, sample 8637.82)
2. zkSync: 213 ms (p99 620 ms, success 99.7%, sample 8637.82)
3. Tenderly: 330 ms (p99 416 ms, success 100.0%, sample 8640.82)
4. 1RPC: 1.20 s (p99 3.98 s, success 0.6%, sample 8639.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="zksync". Provider coverage: 4 no-key endpoints (dRPC, 1RPC, Tenderly, zkSync). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Cronos RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/cronos-rpc
- JSON: https://openchainbench.com/api/stat/cronos-rpc
- Status: live
- Headline: Cronos leads rpc latency at 35 ms (p50, 24h) on Fastest free Cronos RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Cronos: 35 ms (p99 80 ms, success 100.0%, sample 8637.82)
2. PublicNode: 110 ms (p99 729 ms, success 100.0%, sample 8635.82)
3. dRPC: 263 ms (p99 478 ms, success 85.8%, sample 8635.82)
4. 1RPC: 1.17 s (p99 4.47 s, success 0.6%, sample 8636.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="cronos". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, 1RPC, Cronos). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Fraxtal RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/fraxtal-rpc
- JSON: https://openchainbench.com/api/stat/fraxtal-rpc
- Status: live
- Headline: Fraxtal leads rpc latency at 32 ms (p50, 24h) on Fastest free Fraxtal RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Fraxtal: 32 ms (p99 90 ms, success 100.0%, sample 8638.82)
2. dRPC: 177 ms (p99 267 ms, success 86.1%, sample 8637.82)
3. PublicNode: 276 ms (p99 704 ms, success 100.0%, sample 8639.82)
4. Tenderly: 328 ms (p99 426 ms, success 100.0%, sample 8640.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="fraxtal". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Fraxtal). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest free Soneium RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/soneium-rpc
- JSON: https://openchainbench.com/api/stat/soneium-rpc
- Status: live
- Headline: Soneium leads rpc latency at 18 ms (p50, 24h) on Fastest free Soneium RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Soneium: 18 ms (p99 67 ms, success 100.0%, sample 8636.82)
2. dRPC: 179 ms (p99 542 ms, success 85.8%, sample 8636.82)
3. PublicNode: 301 ms (p99 694 ms, success 100.0%, sample 8636.82)
4. Tenderly: 328 ms (p99 370 ms, success 100.0%, sample 8638.82)

**Methodology**:
- Cadence: every 15 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain="soneium". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Soneium). Exclusions follow the cluster-wide rules documented on the parent benchmark.

---
Want machine-readable indexes?
- JSON index: https://openchainbench.com/api/citable
- OpenAPI: https://openchainbench.com/api/openapi.json
- MCP server: https://openchainbench.com/api/mcp/mcp
- llms.txt: https://openchainbench.com/llms.txt