# OpenChainBench live state

> Auto-refreshed every 60s · last fetch 2026-08-16T08:13:24.096Z · 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.7 s, success 99.6%, sample 68836)
2. Codex: 0.9 s (p99 1.6 s, success 95.0%, sample 65698)
3. GeckoTerminal: 15 s (p99 1.0 min, success 99.6%, sample 68843)

**Methodology**:
- Aggregators measured: Mobula, Codex, GeckoTerminal.
- Chains: Base, BNB Chain, Solana, Robinhood Chain.
- 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 × 4 chains × 3 regions = 36 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: Squid Router leads quote latency at 322 ms (p50, 24h) on Fastest cross-chain bridge quote API, live ms ranking.

**Rankings (p50, 24h):**
1. Squid Router: 322 ms (p99 957 ms, success 99.7%, sample 287.05)
2. Mobula: 324 ms (p99 10.00 s, success 99.0%, sample 285.05)
3. deBridge: 656 ms (p99 1.89 s, success 100.0%, sample 288.05)
4. Across: 840 ms (p99 4.83 s, success 100.0%, sample 288.05)
5. Relay: 986 ms (p99 1.93 s, success 100.0%, sample 288.05)
6. Socket Protocol: 1.53 s (p99 5.30 s, success 100.0%, sample 288.05)
7. LI.FI: 2.55 s (p99 4.80 s, success 100.0%, sample 288.05)
8. Near Intents: 3.53 s (p99 8.66 s, success 100.0%, sample 288.05)

**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.
- Regions: eu-west, us-east, sgp. Three independent instances probe simultaneously; the All-regions aggregate uses the full union; per-region tabs isolate the view to one origin.
- Histogram buckets: 10, 25, 50, 100, 200, 500, 1000, 2000, 5000, 10000 ms. Sub-50ms buckets added 2026-07-13 so solver-cached fast paths (Near Intents on HyperCore in particular) surface their true p50 instead of being floored at the interpolation of the (0, 50] bucket.
- 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: Squid Router leads effective fee at 0.023% (24h avg) on Cheapest cross-chain bridge for USDC at $300 notional.

**Rankings (p50, 24h):**
1. Squid Router: 0.023% (p99 0.027%, success 99.7%, sample 5760)
2. Near Intents: 0.057% (p99 0.058%, success 99.9%, sample 34478)
3. Across: 0.11% (p99 0.14%, success 66.7%, sample 34478)
4. Relay: 0.18% (p99 0.19%, success 100.0%, sample 68956)
5. Mobula: 0.21% (p99 0.21%, success 97.9%, sample 68960)
6. Socket Protocol: 0.23% (p99 0.28%, success 100.0%, sample 5760)
7. LI.FI: 0.54% (p99 0.72%, success 100.0%, sample 68956)
8. deBridge: 0.91% (p99 0.97%, success 100.0%, sample 51717)

**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.
- Aggregation: the headline number is the average of per-corridor 24h medians over the corridors a provider actually quotes. The TRUMP to BRETT calibration route is excluded. Near Intents has no USDT legs, so its aggregate covers the Solana to Base and Arbitrum to HyperCore corridors only. deBridge does not quote the Arbitrum to HyperCore corridor, so its aggregate covers the remaining three. Across also skips Arbitrum to HyperCore, so its aggregate covers the same three corridors as deBridge.
- Normalization: cost is quoted USD in minus quoted USD delivered, the same all-in definition for every provider. Near Intents bundles the destination chain withdrawal fee into its quoted amountOut (the 1Click API documents withdrawFee as already deducted), so no extra gas term is added on top.
- Regions: eu-west, us-east, sgp. Three independent instances probe simultaneously; the All-regions aggregate uses the full union; per-region tabs isolate the view to one origin.
- 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, Across, Near Intents) bake cost into the spread of a settlement intent or optimistic fill rather than charging an explicit fee.
- Excluded by design: Stargate, because its keyless quote endpoint was deprecated in favor of a key-gated LayerZero API, and its on-chain quoteOFT path is same-asset EVM-only, which matches none of this bench's corridors. CCTP, because Circle's burn/mint has no quote that returns a delivered amount; standard transfers mint 1:1 and the whole cost is user-paid gas we would have to estimate ourselves, which breaks the quoted USD in minus quoted USD delivered definition used for every other row.

## 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: Codex leads field coverage at 57.3% (24h avg) on Best crypto data API for token metadata, live across Mobula, Codex, Jupiter.

**Rankings (p50, 24h):**
1. Codex: 57.3% (p99 65.8%, success 100.0%, sample 67931.8)
2. Mobula: 56.9% (p99 62.7%, success 100.0%, sample 67911.6)

**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: single probe origin (one monitor instance on our infrastructure). The bench intentionally declares no region dimension; multi-region would require additional monitor instances and is not currently planned.
- 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 in asset registry, live coverage ranking

- Category: Aggregators
- Metric: Asset-registry chains (count)
- Page: https://openchainbench.com/benchmarks/asset-registry-coverage
- JSON: https://openchainbench.com/api/stat/asset-registry-coverage
- Status: live
- Headline: CoinGecko leads asset-registry chains at 462 (24h) on Crypto data API with most blockchains in asset registry, live coverage ranking.

**Rankings (p50, 24h):**
1. CoinGecko: 462 (p99 462, success 100.0%, sample 462)
2. CoinPaprika: 309 (p99 309, success 100.0%, sample 309)
3. CoinStats: 150 (p99 150, success 100.0%, sample 150)
4. Mobula: 81 (p99 81, success 100.0%, sample 81)

**Methodology**:
- Source: each provider's public asset-registry endpoint.
- CoinGecko: GET /api/v3/asset_platforms (public, no auth). Every chain CoinGecko can look up tokens on by contract address.
- CoinPaprika: GET /v1/contracts (no auth). Lists every platform supported for contract-address lookup.
- CoinStats: GET /wallet/blockchains with X-API-KEY. Chains CoinStats indexes for wallet portfolio and token metadata.
- Mobula: GET /api/1/blockchains with an Authorization key. Chains Mobula covers for token metadata + market data.
- Cadence: full refresh every 6 hours.
- Counting: one count per unique chain (platform slug or chain id, whichever the provider exposes); 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 0.9 s, success 99.4%, sample 206856)
2. BNB: 0.9 s (p99 1.8 s, success 100.0%, sample 191951)
3. Avalanche: 1.2 s (p99 1.2 s, success 100.0%, sample 0)
4. Stellar: 7.1 s (p99 11 s, success 100.0%, sample 13011.3)
5. Solana: 13 s (p99 15 s, success 100.0%, sample 5760)
6. TRON: 56 s (p99 1.0 min, success 100.0%, sample 5760)
7. Ethereum: 15.9 min (p99 19.0 min, success 100.0%, sample 5760)
8. Monero: 19.0 min (p99 31.7 min, success 100.0%, sample 5760)
9. Litecoin: 29.2 min (p99 45.0 min, success 100.0%, sample 5760)
10. Bitcoin: 51.0 min (p99 112.5 min, success 100.0%, sample 148.026)

**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: wall-clock lag of the tonapi.io masterchain head. Masterchain blocks are BFT-final at production, so head commit lag is the finality figure; the chain produces a block about every 0.4s since the accelerated upgrade.
- Bitcoin (probabilistic, own-clock): mempool.space `/blocks/tip/height` polled every 30 s. T1 = first poll where block N is the tip, T2 = first poll where tip − N ≥ 6 (the exchange deposit convention). lag = T2 − T1 on the harness clock; miner-set block timestamps (consensus allows 2h skew) are never used. The startup tip is not timed. On a tip regression, pending timers above the new tip are dropped; same-height reorgs are invisible to height polling, bounding error to about one block interval.
- 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 cost from $1k to $1M on ETH, BTC and SOL

- 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.0029% (24h avg) on Cheapest perp DEX, live all-in cost from $1k to $1M on ETH, BTC and SOL.

**Rankings (p50, 24h):**
1. Lighter: 0.0029% (p99 0.0072%, success 99.7%, sample 5760)
2. Extended: 0.026% (p99 0.028%, success 99.7%, sample 5760)
3. Paradex: 0.037% (p99 0.054%, success 100.0%, sample 5760)
4. gains.trade: 0.040% (p99 0.040%, success 100.0%, sample 5760)
5. Polymarket: 0.041% (p99 0.051%, success 100.0%, sample 5760)
6. Hyperliquid: 0.046% (p99 0.047%, success 100.0%, sample 5760)
7. Aster: 0.050% (p99 0.057%, success 100.0%, sample 5760)
8. GMX v2: 0.060% (p99 0.060%, success 99.3%, sample 5760)
9. dYdX v4: 0.069% (p99 0.12%, success 100.0%, sample 5760)

**Methodology**:
- Cadence: every 5 minutes, in parallel across all venues.
- Trade simulated: a long at 10x, measured independently on ETH, BTC and SOL (the chain tabs scope the board; the unfiltered view averages the three). Headline notional $1,000 with $10k, $100k and $1M tiers rewalked on the same book.
- 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) on the ETH/USD, BTC/USD and SOL/USD markets + gmxinfra REST for funding. Oracle priced, no orderbook: the spread term is zero.
- Lighter: `/orderBookDetails` (taker fee per market) + `/orderBookOrders` (orderbook walk).
- gains.trade (Gains v8 on Base): fees read directly on-chain. `eth_call pairs(N)` gives `spreadP` and `feeIndex`, then `eth_call fees(feeIndex)` gives the open fee (`totalPositionSizeFeeP`). The taker crosses one side of the book, so we charge half of `spreadP`. SOL has `spreadP` 0 on-chain (Gains prices that pair's spread dynamically), so its figure is the open fee alone. Values in 1e10 precision per Gains v8 convention. Fee tier cached 1h, pair config 6h.
- Paradex: `/markets` fee config for the api-tier taker rate + `/orderbook?depth=100` walk. The book endpoint caps at 100 levels (about $1M visible on majors), so the $1M tier can be skipped when the visible book thins.
- Extended: full public book from `/info/markets/<m>/orderbook` + `/stats` funding (1h native). Its taker fee is not exposed by any public endpoint; the documented base rate of 2.5 bps is used and this is the one venue where the fee is not read live.
- All-in formula: `all_in_bps = taker_fee_bps + spread_bps`. Both components emitted as separate metrics for transparency.
- Notional tiers: the same measurement runs at $1,000, $10,000, $100,000 and $1,000,000 by rewalking the already fetched book, published to `perp_fees_all_in_bps_tier{venue, chain, notional}`. The headline `perp_fees_all_in_bps` stays defined at $1,000. A tier the book cannot fill is skipped and counted in `perp_fees_tier_skipped_total`, never extrapolated. Oracle priced venues (GMX v2, gains.trade) charge a flat percentage of size, so their figure repeats across tiers.
- Book depth for the $1M tier: Lighter is walked on its top 100 levels, dYdX on the full indexer book, Polymarket on up to 500 levels. Hyperliquid returns its 20 best raw levels; when those cannot absorb the tier the harness refetches with nSigFigs=5, the finest price aggregation the API offers, which extends coverage with negligible price rounding.
- 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.1% (24h avg) on Best wallet labeling API provider.

**Rankings (p50, 24h):**
1. Helius: 84.1% (p99 84.1%, success 100.0%, sample 921.158)
2. XRPScan: 80.1% (p99 80.1%, success 90.0%, sample 482.083)
3. StellarExpert: 79.9% (p99 79.9%, success 79.9%, sample 483.083)
4. OLI: 50.4% (p99 50.4%, success 100.0%, sample 5588.96)
5. Moralis: 44.8% (p99 44.8%, success 99.8%, sample 1319.23)
6. Mobula: 43.7% (p99 43.7%, success 99.7%, sample 8638.48)
7. Blockscout: 40.5% (p99 40.5%, success 74.9%, sample 4031.69)
8. TonAPI: 35.5% (p99 35.5%, success 78.5%, sample 678.116)
9. WalletExplorer: 20.0% (p99 20.0%, success 99.2%, sample 485.083)

**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 Robinhood, Arbitrum, Base and 7 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: Robinhood Chain leads block time at 79 ms (p50, 24h) on Fastest L2 block time, live across Robinhood, Arbitrum, Base and 7 more.

**Rankings (p50, 24h):**
1. Robinhood Chain: 79 ms (p99 195 ms, success 100.0%, sample 861279)
2. Arbitrum One: 331 ms (p99 500 ms, success 100.0%, sample 342584)
3. Mantle: 1.85 s (p99 2.98 s, success 100.0%, sample 43199.9)
4. Base: 1.94 s (p99 2.98 s, success 100.0%, sample 43199.9)
5. Optimism: 1.94 s (p99 2.99 s, success 100.0%, sample 43199.9)
6. Taiko: 1.98 s (p99 3.00 s, success 100.0%, sample 42915.9)
7. Blast: 1.98 s (p99 2.98 s, success 100.0%, sample 43199.9)
8. zkSync Era: 5.82 s (p99 58.64 s, success 99.3%, sample 8831.41)
9. Linea: 8.00 s (p99 57.22 s, success 100.0%, sample 7502.2)
10. Scroll: 8.70 s (p99 1.0 min, success 99.2%, sample 6836.09)

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

## Fastest free public RPC for Ethereum, BNB, Polygon and 23 more chains (plus Solana and Polkadot)

- 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 74 ms (p50, 24h) on Fastest free public RPC for Ethereum, BNB, Polygon and 23 more chains (plus Solana and Polkadot).

**Rankings (p50, 24h):**
1. Binance: 74 ms (p99 365 ms, success 100.0%, sample 4316.71)
2. Avalanche: 176 ms (p99 328 ms, success 100.0%, sample 4323.71)
3. PublicNode: 199 ms (p99 800 ms, success 82.1%, sample 267478)
4. dRPC: 223 ms (p99 604 ms, success 89.1%, sample 262846)
5. Nodies: 226 ms (p99 580 ms, success 66.7%, sample 25911.3)
6. Arbitrum: 252 ms (p99 414 ms, success 100.0%, sample 4323.71)
7. Base: 258 ms (p99 388 ms, success 100.0%, sample 4324.71)
8. MeowRPC: 273 ms (p99 498 ms, success 98.5%, sample 8637.43)
9. Lava: 283 ms (p99 2.11 s, success 99.3%, sample 21542.6)
10. Tenderly: 315 ms (p99 391 ms, success 100.0%, sample 125135)
11. Optimism: 334 ms (p99 409 ms, success 100.0%, sample 4324.71)
12. Flashbots: 696 ms (p99 975 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 seconds per (provider, chain) pair, from each of 3 Railway replicas (us-east Virginia, eu-west Amsterdam, sgp Singapore). The harness stamps a `region` label on every metric from `$RAILWAY_REPLICA_REGION`. Headline p50/p90/p99 are the mean of per (chain, region) `quantile_over_time` cells: all 3 regions, and on the All chains tab every chain the provider serves. Per-region breakdowns are on the time-series chart.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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`. Latency is recorded only for calls classified `ok`; failed calls never enter the latency distribution, so every percentile is conditional on success.
- 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.
- Success gating: because failed probes record no latency, a mostly failing endpoint can post a fast p50 from its rare successes. The ledger pairs every latency figure with a Success column computed as ok calls over total calls in the same 24h window; read rows below 50 percent success as degraded. Providers with under 5 percent success lose their latency series to Prometheus staleness and are pinned below the table as unresponsive instead of being ranked.
- 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: 26 chains (24 EVM plus Solana and Polkadot). EVM majors: Ethereum, Arbitrum, Base, Optimism, Avalanche, BNB, Polygon, Linea, Scroll, Mantle. EVM long-tail: Sonic, Gnosis, Celo, Blast, Taiko, Moonbeam, Berachain, zkSync, Cronos, Fraxtal, Unichain, Soneium, Monad, MegaETH. Non-EVM: Solana (getSlot probe), Polkadot (chain_getHeader probe). Provider matrix per chain is documented in `harnesses/rpc-capabilities/cmd/script/config.go`.
- Excluded: 1RPC (delisted 2026-07-09, under 13% success even at two chains and one probe per minute), 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). Blink, formerly Merkle (no public eth_getBlockByNumber) + Lava and MeowRPC outside ETH/Arb excluded. 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) (gwei)
- 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 gwei (p50, 24h) on Most accurate gas oracle, live gap vs realized priority fee.

**Rankings (p50, 24h):**
1. Owlracle: ~0 gwei (p99 ~0 gwei, success 79.9%, sample 5761)
2. MetaMask: ~0 gwei (p99 0 gwei, success 84.2%, sample 28802)
3. PublicNode: ~0 gwei (p99 0 gwei, success 78.4%, sample 28802)
4. Etherscan: ~0 gwei (p99 0 gwei, success 86.3%, sample 17280)

**Methodology**:
- Chains: Ethereum (chainid=1), Polygon PoS (chainid=137), Arbitrum One (chainid=42161). Ethereum and Polygon are EIP-1559 with dynamic base fee. Arbitrum is included as an L2 reference where priority fee converges to ~0 (centralised sequencer, no MEV auction); the bench shows this empirically. Actually-meaningful L2 cost is L1 data fee, planned for a separate bench. BNB Chain excluded (not EIP-1559). Avalanche C-Chain also collapses to ~0 priority.
- Oracles per chain. Ethereum + Polygon: PublicNode feeHistory, Owlracle, Etherscan v2 (free tier), MetaMask. Avalanche: same set minus Etherscan (free plan restricted for chainid 43114).
- Per-oracle endpoints. PublicNode `eth_feeHistory` on each chain's RPC; Owlracle `/v4/{eth|poly|avax}/gas` (slug per chain); Etherscan v2 `?chainid=<N>&module=gastracker&action=gasoracle`; MetaMask `gas.api.cx.metamask.io/networks/<N>/suggestedGasFees` (public no-key, EIP-1559 low/medium/high mapped to p25/p50/p90).
- Cadences. PublicNode feeHistory and MetaMask 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 primary RPC and computes p25/p50/p75/p90/p99 directly from the actual effective `maxPriorityFeePerGas` values across every included transaction. Every tier is a real percentile of the mined block, none are interpolated. 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-side independence check. Each chain configures a second RPC on a different upstream (dRPC / native chain RPC) as `GAS_REALIZED_RPC_VERIFY_<CHAIN>`; on each block the harness cross-checks baseFee and increments `gas_realized_quorum_disagreement_total{chain, kind}` on mismatch. Primary is still trusted; the counter makes visible whether our ground truth is actually independent across upstreams.
- 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.
- Prediction age disclosure. `gas_prediction_age_seconds{oracle, chain}` records the wall-clock time between an oracle's poll returning and the realized block being graded. This surfaces the free-tier cadence asymmetry (Owlracle at 60s vs PublicNode at 12s vs Etherscan at 15s) so readers can see how much of an oracle's error is stale-sample rather than model quality; it is not part of the ranking, only a diagnostic column.
- Over/under split. In parallel with the absolute-error histogram, the harness emits `gas_error_priority_over_gwei_histogram` (predicted > realized, cost = overpay) and `gas_error_priority_under_gwei_histogram` (predicted < realized, cost = transaction stuck). Same buckets. The two branches lets the leaderboard decompose asymmetric behaviour: inclusion-confidence oracles skew fat on the over side by design, percentile trackers skew fat on the under side during spikes.
- Lag=2 secondary grade. `gas_error_priority_lag2_gwei_histogram` grades each prediction against the block 2 slots after its target, not the very-next block. Removes the latency-race bias where whoever scraped the mempool 100ms before us wins by construction; closer to the wallet UX (sign, broadcast, propagate) than block+1. Same buckets as the primary histogram so a leaderboard column can plot the two side by side.
- Asymmetric Pinball Loss (APL). `gas_error_priority_apl_gwei_histogram` emits a proper scoring rule (Koenker & Bassett 1978): per sample `(1-τ)·over_gap` if the oracle over-predicted, else `τ·under_gap`, with τ=0.9. Encodes wallet UX asymmetry: under-prediction (tx stuck) is 9× more costly than over-prediction (small overpay). Same buckets as the abs error histogram. Rank-stable at n=few-hundred samples where p99 of abs error is still dominated by 2-3 tail blocks.
- 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.0029% (24h avg) on Most stable stablecoin, live peg deviation across USDC, USDT and DAI.

**Rankings (p50, 24h):**
1. DAI: 0.0029% (p99 0.0039%, success 100.0%, sample 7200.24)
2. USDC: 0.015% (p99 0.025%, success 100.0%, sample 51840)
3. USDT: 0.11% (p99 0.12%, success 100.0%, sample 51840)

**Methodology**:
- Sources per stable, USDC: Binance USDC/USDT (USDT-anchored, secondary), Kraken USDCUSD, Bitstamp usdcusd. USDT: Coinbase USDT-USD, Kraken USDTUSD, Bitstamp usdtusd. FDUSD: Binance FDUSDUSDT (USDT-anchored, secondary). USDe: Binance USDEUSDT (USDT-anchored, secondary). DAI: Curve 3pool `get_dy`, quoted forward (USDC → DAI) and reverse (DAI → USDC), published as the geometric mean of the two quotes.
- DAI's source class differs from the rest. No liquid CEX USD pair for DAI exists (live check July 2026: Kraken DAIUSD under $150k per 24 h with a 9 bps spread, Bitstamp at zero volume, Coinbase DAI-USD delisted), so DAI is measured from the Curve 3pool on-chain quote while USDC and USDT come from CEX tickers. The geometric mean of forward and reverse `get_dy` cancels the pool swap fee; residual pool imbalance is DAI's genuine price signal, not an artifact.
- 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 bps. The ledger sorts on `quantile_over_time(0.50, peg_deviation_worst_bps[24h])`, the 24 h median (everyday tightness); the p99 column is the depeg tail. Per-minute max surfaces sub-minute depeg wicks a median would smooth away. 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 USDT at $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: USDC leads usdt-pair spread at 0.093% (24h avg) on Cheapest USDT stablecoin swap on Binance, live USDC, FDUSD, USDe spread.

**Rankings (p50, 24h):**
1. USDC: 0.093% (p99 0.098%, success 100.0%, sample 17280)
2. USDe: 0.095% (p99 0.095%, success 100.0%, sample 17280)
3. FDUSD: 0.21% (p99 0.21%, 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 103.5% (24h avg) on DeFi token buyback tracker, live executed vs promised ratio.

**Rankings (p50, 24h):**
1. Hyperliquid: 103.5% (p99 103.5%, success 100.0%, sample 5861180)

**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: BNB/USD leads max cross-oracle deviation at 0.10% (24h avg) on Chainlink vs Pyth vs Binance vs Coinbase, live oracle deviation.

**Rankings (p50, 24h):**
1. BNB/USD: 0.10% (p99 0.14%, success 100.0%, sample 23040)
2. XRP/USD: 0.10% (p99 0.13%, success 100.0%, sample 17280)
3. ADA/USD: 0.11% (p99 0.17%, success 100.0%, sample 17280)
4. ETH/USD: 0.11% (p99 0.12%, success 100.0%, sample 23040)
5. LINK/USD: 0.11% (p99 0.17%, success 100.0%, sample 23040)
6. SOL/USD: 0.11% (p99 0.13%, success 100.0%, sample 23040)
7. POL/USD: 0.11% (p99 0.22%, success 100.0%, sample 23040)
8. AVAX/USD: 0.11% (p99 0.16%, success 100.0%, sample 23040)
9. BTC/USD: 0.11% (p99 0.13%, success 100.0%, sample 23040)
10. DOGE/USD: 0.11% (p99 0.16%, success 100.0%, sample 17280)

**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 7 PoS chains

- Category: Blockchains
- Metric: Net yield (bps)
- Page: https://openchainbench.com/benchmarks/validator-yield
- JSON: https://openchainbench.com/api/stat/validator-yield
- Status: live
- Headline: Cosmos Hub leads net yield at 9.76% (24h avg) on Highest staking yield, live validator net APR across 7 PoS chains.

**Rankings (p50, 24h):**
1. Cosmos Hub: 9.76% (p99 9.79%, success 100.0%, sample 200)
2. Avalanche: 6.80% (p99 8.33%, success 100.0%, sample 100)
3. Solana: 5.12% (p99 5.42%, success 100.0%, sample 200)
4. Cardano: 4.95% (p99 5.00%, success 100.0%, sample 50)
5. Ethereum: 2.56% (p99 2.56%, success 100.0%, sample 1)
6. Hyperliquid: 2.18% (p99 2.24%, success 100.0%, sample 34)

**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.
- Ethereum. Source: `GET ultrasound.money/api/v2/fees/effective-balance-sum` (free, no key), live total beacon-chain effective balance. APR = 64 × epochs_per_year / sqrt(total_gwei), the consensus spec reward formula at 100% participation (realized ~99.5%, under 2 bps of drift). One network-average series: consensus rewards are uniform per 32 ETH increment, so the average equals the solo validator nominal APR. Execution tips and MEV excluded. Price: CoinGecko (ETH/USD).
- 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. Per-validator Ethereum gauges (~1M indices; beacon-node ingestion, v2). Ethereum execution tips + MEV (per-relay MEV-Boost scraping needed; published figure is consensus only). Lido/RocketPool/Coinbase are products with fees, not validator yields (separate bench). Polkadot v2. Cosmos Hub, Avalanche, Cardano, Sui now tracked.

## 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: Invo leads builder fees collected (usd) at $7,832.94 (24h) on Hyperliquid frontends builder revenue leaderboard.

**Rankings (p50, 24h):**
1. Invo: $7,832.94 (p99 $0.9446, success 100.0%, sample 75676)
2. Phantom: $7,770.26 (p99 $4.78, success 100.0%, sample 14135)
3. MetaMask: $6,883 (p99 $10.72, success 100.0%, sample 9416)
4. Trust Wallet: $4,035.23 (p99 $7.03, success 100.0%, sample 4462)
5. FOMO: $2,073.97 (p99 $2.57, success 100.0%, sample 5807)
6. Bitget Wallet: $1,643.59 (p99 $13.04, success 100.0%, sample 1300)
7. 0x7cc0…e781: $1,183.63 (p99 $0.7917, success 100.0%, sample 7901)
8. Onchain.cc: $1,009.5 (p99 $1.2, success 100.0%, sample 12898)
9. Rabby: $991.34 (p99 $2.58, success 100.0%, sample 5058)
10. 0x42f3…f992: $832.98 (p99 $9.26, success 100.0%, sample 6428)
11. Liquid Perps: $721.59 (p99 $2.99, success 100.0%, sample 2785)
12. Tread.fi: $646.57 (p99 $9.65, success 100.0%, sample 20376)
13. Wunder: $500.99 (p99 $5.69, success 100.0%, sample 1197)
14. OneKey: $464.78 (p99 $6.55, success 100.0%, sample 960)
15. Hyperdash: $448.93 (p99 $4.4, success 100.0%, sample 2124)
16. Insilico: $361.56 (p99 $3.41, success 100.0%, sample 5074)
17. Dreamcash: $320.86 (p99 $3.27, success 100.0%, sample 1146)
18. Markets Mobile: $307.74 (p99 $6.69, success 100.0%, sample 701)
19. Metascalp: $297.83 (p99 $2.4, success 100.0%, sample 13453)
20. ApexLiquid: $293.5 (p99 $7.34, success 100.0%, sample 1934)
21. Nansen: $275 (p99 $5.85, success 100.0%, sample 691)
22. Pear: $244.72 (p99 $7.42, success 100.0%, sample 1019)
23. MetaMask (alt): $233.51 (p99 $5.56, success 100.0%, sample 583)
24. 0x446f…d6c6: $184.77 (p99 $92.39, success 100.0%, sample 132)
25. HyperX: $182.61 (p99 $6.76, success 100.0%, sample 4199)
26. Legend Trade: $182.18 (p99 $2.99, success 100.0%, sample 981)
27. Axiom: $181.89 (p99 $1.46, success 100.0%, sample 1820)
28. based.app: $175.76 (p99 $1.02, success 100.0%, sample 2657)
29. Moonbot: $147.38 (p99 $4.21, success 100.0%, sample 1881)
30. BullpenFi: $136.8 (p99 $2.36, success 100.0%, sample 365)
31. defi.app: $135.95 (p99 $10.46, success 100.0%, sample 271)
32. Mass.money: $134.55 (p99 $5.18, success 100.0%, sample 359)
33. 0xdbc2…97a6: $126.04 (p99 $2.63, success 100.0%, sample 422)
34. 0xf85a…5688: $123.99 (p99 $20.67, success 100.0%, sample 135)
35. Dexari: $68.08 (p99 $13.62, success 100.0%, sample 104)
36. 0x53a1…fcd1: $60.76 (p99 $3.2, success 100.0%, sample 128)
37. Rainbow: $58.73 (p99 $1.68, success 100.0%, sample 169)
38. Infinex: $55.07 (p99 $4.59, success 100.0%, sample 53)
39. Dexly Trade: $53.42 (p99 $2.97, success 100.0%, sample 195)
40. 0x9f83…31d9: $46.72 (p99 $1.61, success 100.0%, sample 147)
41. Sushi: $40.23 (p99 $20.12, success 100.0%, sample 127)
42. Miracle: $31.72 (p99 $3.52, success 100.0%, sample 34)
43. CCXT: $29.38 (p99 $0.5154, success 100.0%, sample 1754)
44. pvp.trade: $29.23 (p99 $4.18, success 100.0%, sample 56)
45. Origami Tech: $28.34 (p99 $5.67, success 100.0%, sample 756)
46. goodcryptoX: $27.1 (p99 $0.8468, success 100.0%, sample 282)
47. Senpi: $26.8 (p99 $0.3229, success 100.0%, sample 456)
48. tuleep.trade: $21.73 (p99 $7.24, success 100.0%, sample 93)
49. VergeX: $17.55 (p99 $0.3815, success 100.0%, sample 305)
50. Dextrabot: $17.52 (p99 $1.46, success 100.0%, sample 727)
51. 0xc95d…1aca: $17.13 (p99 $5.71, success 100.0%, sample 526)
52. MinaraAI: $16.54 (p99 $0.0321, success 100.0%, sample 2443)
53. Arena: $14.93 (p99 $2.13, success 100.0%, sample 35)
54. CoinPilot: $13.85 (p99 $0.2946, success 100.0%, sample 439)
55. Liminal: $11.84 (p99 $3.95, success 100.0%, sample 41)
56. cro.trade: $9.26 (p99 $2.32, success 100.0%, sample 39)
57. UnityWallet: $3.24 (p99 $3.24, success 100.0%, sample 37)
58. Okto: $2.71 (p99 $0.4511, success 100.0%, sample 27)
59. Tradoor: $2.66 (p99 $2.66, success 100.0%, sample 341)
60. Wallet V: $2.42 (p99 $0.3452, success 100.0%, sample 37)
61. STRYX: $1.89 (p99 $1.89, success 100.0%, sample 1)
62. MarsGO: $1.71 (p99 $1.71, success 100.0%, sample 2)
63. SuperCEXy: $1.4 (p99 $0.7007, success 100.0%, sample 6)
64. DeFi Saver: $1.33 (p99 $1.33, success 100.0%, sample 9)
65. Hyprearn: $0.6906 (p99 $0.1381, success 100.0%, sample 31)
66. XBIT: $0.4352 (p99 $0.4352, success 100.0%, sample 6)
67. Gem Wallet: $0.4174 (p99 $0.4174, success 100.0%, sample 2)
68. PerpsWLD: $0.4055 (p99 $0.0676, success 100.0%, sample 9)
69. Coin98: $0.2211 (p99 $0.2211, success 100.0%, sample 2)
70. Cwallet: $0.0606 (p99 $0.0202, success 100.0%, sample 13)
71. Lit Trade: $0.0512 (p99 $0.0512, success 100.0%, sample 6)
72. 0xb290…c34a: $0.0411 (p99 $0.0206, success 100.0%, sample 3)
73. Katoshi: $0.0227 (p99 $0.0227, success 100.0%, sample 2)
74. VOOI: $0.00183 (p99 $0.000916, success 100.0%, sample 19)

**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.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 15 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.0000993 (24h) on Cheapest blockchain transaction fee, live across 15 L1 and L2 chains.

**Rankings (p50, 24h):**
1. Litecoin: $0.0000993 (p99 $0.0000997, success 100.0%, sample 40311)
2. Base: $0.000237 (p99 $0.00205, success 100.0%, sample 40311)
3. Taiko: $0.000346 (p99 $0.00133, success 100.0%, sample 40311)
4. Solana: $0.000377 (p99 $0.0151, success 100.0%, sample 40311)
5. Mantle: $0.000459 (p99 $0.000842, success 100.0%, sample 40311)
6. BNB Chain: $0.000733 (p99 $0.0303, success 100.0%, sample 40311)
7. Arbitrum One: $0.000791 (p99 $0.000801, success 100.0%, sample 40311)
8. Robinhood Chain: $0.00114 (p99 $0.00134, success 100.0%, sample 40311)
9. zkSync Era: $0.00179 (p99 $0.00179, success 100.0%, sample 40311)
10. Ethereum: $0.00225 (p99 $0.1632, success 100.0%, sample 40311)
11. Linea: $0.0117 (p99 $0.0573, success 100.0%, sample 40311)
12. Cardano: $0.0295 (p99 $0.0298, success 100.0%, sample 40311)
13. Monero: $0.0491 (p99 $0.1983, success 100.0%, sample 40311)
14. TRON: $0.0937 (p99 $0.0937, success 100.0%, sample 40311)

**Methodology**:
- Refresh cadence. 30 seconds. One process samples all 15 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 15 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 EVM swap quote API

- Category: Aggregators
- Metric: Quote latency (ms)
- Page: https://openchainbench.com/benchmarks/evm-quote-latency
- JSON: https://openchainbench.com/api/stat/evm-quote-latency
- Status: live
- Headline: Mobula leads quote latency at 169 ms (p50, 24h) on Fastest EVM swap quote API.

**Rankings (p50, 24h):**
1. Mobula: 169 ms (p99 827 ms, success 100.0%, sample 4319.98)
2. KyberSwap: 194 ms (p99 1.31 s, success 100.0%, sample 4319.98)
3. Bebop: 548 ms (p99 1.72 s, success 100.0%, sample 4319.98)
4. LI.FI: 1.02 s (p99 3.91 s, success 62.6%, sample 2700.61)
5. Enso: 1.16 s (p99 3.30 s, success 100.0%, sample 4319.98)
6. CoW Protocol: 3.10 s (p99 4.96 s, success 100.0%, sample 3456.78)

**Methodology**:
- Five fixed pairs across four chains. Polygon and Optimism will be added in v2 once they reach a comparable sample volume.
- 60 second tick, one pair per tick, round robin. Every (provider, chain) sees a quote every 5 minutes.
- Three regions (us east, eu west, sgp). Each is a separate Railway service writing the same metric family with a region label, so the page can filter to a single edge or aggregate across all three.
- Latency is wall clock from request dispatch to last byte received, observed only on the happy path (HTTP 2xx and a parseable output amount). Failures land on dedicated counters (auth, throttle, no route, other) and pull the success gauge to 0.
- Native asset sentinel is the canonical 0xEeeeeEeee form. Odos uses 0x0000... and Bebop substitutes the wrapped equivalent on the sell side. The adapter normalises per provider.
- Provider auth: Mobula requires the sponsor key in an Authorization header. KyberSwap, Bebop, LI.FI and OpenOcean accept anonymous traffic.

## 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.000977 (24h) on Cheapest blockchain to deploy a token, live USD cost across 7 non-EVM L1 chains.

**Rankings (p50, 24h):**
1. Osmosis: $0.000977 (p99 $0.000992, success 100.0%, sample 40311)
2. Aptos: $0.0808 (p99 $0.0816, success 100.0%, sample 40311)
3. Cardano: $0.2080 (p99 $0.2100, success 100.0%, sample 40311)
4. Sui: $0.3383 (p99 $0.3415, success 100.0%, sample 40311)
5. Stellar: $0.3947 (p99 $0.3981, success 100.0%, sample 40311)
6. Injective: $0.4184 (p99 $0.4216, success 100.0%, sample 40311)
7. Solana: $0.6878 (p99 $0.6898, success 100.0%, sample 40311)

**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 = 5 base reserves (the protocol minimum of 2 per new account for issuer and distribution, plus 1 for the trustline) + 2 base fees (create_account + change_trust). Reserves are locked capital, refundable on account closure, counted here because bringing the asset into existence requires them upfront. 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 $10.0K (24h) on Hyperliquid HIP-3 deployer revenue leaderboard.

**Rankings (p50, 24h):**
1. trade.xyz: $10.0K (p99 $0.2059, success 100.0%, sample 993360)
2. Paragon: $77.68 (p99 $0.3938, success 100.0%, sample 17554)
3. HyENA: $48 (p99 $0.2172, success 100.0%, sample 3616)

**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: Aster leads funding cost to hold a long 24h at 0.61 bps (p50, 24h) on Cheapest perp venue to hold a position, live funding normalized.

**Rankings (p50, 24h):**
1. Aster: 0.61 bps (p99 -0.75 bps, success 100.0%, sample 2880)
2. Binance: 0.81 bps (p99 -1.30 bps, success 100.0%, sample 2880)
3. OKX: 1.31 bps (p99 -0.47 bps, success 100.0%, sample 2880)
4. Hyperliquid: 1.53 bps (p99 1.69 bps, success 100.0%, sample 2880)
5. Bybit: 1.63 bps (p99 0.74 bps, success 100.0%, sample 2880)
6. Paradex: 1.91 bps (p99 1.18 bps, success 100.0%, sample 2880)

**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 94 ms (p50, 24h) on Prediction market API rate limits, tested with a daily ramp.

**Rankings (p50, 24h):**
1. Limitless: 94 ms (p99 589 ms, success 100.0%, sample 51832.5)
2. Polymarket: 200 ms (p99 250 ms, success 100.0%, sample 51822.6)
3. Kalshi: 289 ms (p99 464 ms, success 100.0%, sample 51833)
4. Manifold: 325 ms (p99 399 ms, success 100.0%, sample 37028.8)
5. Myriad: 496 ms (p99 2.65 s, success 99.6%, sample 51755.5)

**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, PredictIt, Metaculus: price and list only (no order book). Smarkets: `/v3/markets/{id}/quotes/`, `/v3/markets/{id}/`, `/v3/events/`.
- 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 tiers: Polymarket + Kalshi 25/50/100 per 10s, Manifold 15/30/60, Limitless 10/20/40, Smarkets 10/25/50, Metaculus 5/10/20. Kalshi stops at first 429 (documented token bucket). Myriad excluded (keyless budget 30/10s). PredictIt excluded (5 req/min published limit).
- 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@openchainbench.com)`. 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 97 ms (p50, 24h) on Best prediction market API, ranked by live latency and uptime.

**Rankings (p50, 24h):**
1. Limitless: 97 ms (p99 511 ms, success 100.0%, sample 51832)
2. Polymarket: 200 ms (p99 250 ms, success 100.0%, sample 51817.6)
3. Kalshi: 290 ms (p99 437 ms, success 100.0%, sample 51830.7)
4. Myriad: 496 ms (p99 2.65 s, success 99.6%, sample 51757.4)
5. Manifold: 2.50 s (p99 3.97 s, success 100.0%, sample 37020.4)

**Methodology**:
- Price endpoint per venue. Polymarket: CLOB `/midpoint`. Kalshi: `/markets/{ticker}`. Limitless: `/markets/{slug}`. Manifold: `/v0/market/{id}`. Myriad: `/markets/{slug}`. PredictIt: `/api/marketdata/markets/{id}` (15s interval, 5 req/min limit). Smarkets: `/v3/markets/{id}/`. Metaculus: `/api2/questions/{id}/`. 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). WebSocket connect-to-snapshot and trade publication lag are measured in pm-ws-latency (bench 114). 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@openchainbench.com)`. We publish latency and uptime measurements only, never market data.
- Data aggregators that resell venue prices are deliberately excluded from this leaderboard. 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. 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.

## Resolution delay, Polymarket vs Kalshi

- Category: Trading
- Metric: Resolution delay (s)
- Page: https://openchainbench.com/benchmarks/pm-resolution-delay
- JSON: https://openchainbench.com/api/stat/pm-resolution-delay
- Status: live
- Headline: Kalshi — All leads resolution delay at 9.0 min (p50, 24h) on Resolution delay, Polymarket vs Kalshi.

**Rankings (p50, 24h):**
1. Kalshi — All: 9.0 min (p99 14.9 min, success 100.0%, sample 36)
2. Kalshi — Sports: 9.0 min (p99 14.9 min, success 100.0%, sample 36)
3. Polymarket — Crypto: 10.4 min (p99 161.1 min, success 100.0%, sample 15638)
4. Polymarket — Sports: 136.3 min (p99 238.8 min, success 100.0%, sample 196521)
5. Polymarket — All: 140.7 min (p99 239.4 min, success 100.0%, sample 286702)
6. Polymarket — Other: 164.6 min (p99 409.4 min, success 100.0%, sample 73276)
7. Polymarket — Politics: 189.8 min (p99 688.4 min, success 100.0%, sample 1267)

**Methodology**:
- Polymarket anchor: the first OO ProposePrice block timestamp, not Gamma fields. Verified live: Gamma closedTime equals the QuestionResolved block timestamp (circular by construction) and endDate is a scheduled buffer most markets beat.
- Polymarket sources: Polygon logs of the post-migration UMA CTF adapters (binary 0x65070BE9..., neg-risk 0x69c47De9...) and their Optimistic Oracle (0x2c0367a9...). Gamma supplies the market catalogue and category tags.
- Polymarket join: questionID = keccak256 of the proposal ancillary data, verified against QuestionInitialized events.
- Kalshi anchor: settlement_ts from the public markets API (exact timestamp, no polling error). Delay = settlement_ts - close_time. close_time is the scheduled market close, not the real-world event end.
- Kalshi scope: traditional prediction markets only. Exotics (auto-generated multivariate parlays) are excluded by design: they auto-settle so fast they never appear in status=closed, so the watchlist only contains real market questions. Categories from /events/{event_ticker} (lazy cache): Sports→sports, Politics/Elections→politics, Crypto/Financials→crypto, everything else→other.
- Anchor asymmetry: Polymarket's 2h UMA challenge window is protocol-enforced: no market can resolve in under 2h on the clean path. Kalshi has no such floor; traditional sports and politics markets settle in minutes to hours after close_time. The difference in distributions reflects both operational speed and architecture.
- Categories: sports, politics, crypto, other, consistent across venues. Per-category rows are the honest unit of comparison because market types run different resolution windows.
- Disputes (Polymarket only): a DisputePrice before resolution marks the market disputed. Disputed delays land in the disputed series and are excluded from the main category rows.
- Pending backlog (Polymarket only): markets past their scheduled endDate with no onchain resolution, polled from Gamma every cycle.
- Listener: 45s incremental Polygon log polling with a 7-day chunked backfill on restart. Kalshi poller ticks every 5 min. Both coexist in the same process.

## 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 97.1% (24h avg) on Best NFT collection metadata API: Moralis, Alchemy, OpenSea benchmarked.

**Rankings (p50, 24h):**
1. Moralis: 97.1% (p99 97.1%, success 100.0%, sample 3665.63)
2. OpenSea: 94.7% (p99 94.7%, success 100.0%, sample 4290.75)
3. Alchemy: 73.8% (p99 73.8%, success 100.0%, sample 6001.04)

**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 $1.12B (24h) on Perp DEX volume share, live 24h notional ranked.

**Rankings (p50, 24h):**
1. Hyperliquid: $1.12B (p99 $1.90B, success 85.7%, sample 5760)
2. Aster: $490.15M (p99 $878.38M, success 85.7%, sample 5760)
3. Lighter: $488.69M (p99 $780.35M, success 85.7%, sample 5760)
4. GRVT: $342.10M (p99 $439.68M, success 71.4%, sample 5760)
5. Extended: $245.16M (p99 $492.04M, success 84.6%, sample 5760)
6. Pacifica: $231.68M (p99 $494.03M, success 71.4%, sample 5760)
7. Vertex: $23.15M (p99 $44.17M, success 85.7%, sample 5760)
8. Polymarket: $18.87M (p99 $42.09M, success 80.0%, sample 5760)
9. dYdX v4: $5.52M (p99 $12.00M, success 85.7%, sample 5760)
10. Paradex: $3.10M (p99 $4.71M, success 85.7%, sample 5760)
11. Aevo: $1.23M (p99 $1.52M, success 71.4%, sample 5760)

**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 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: Coinbase leads 24h eth funding stddev at 0.0032% (24h avg) on Perp DEX funding stability, 24h stddev of ETH funding ranked.

**Rankings (p50, 24h):**
1. Coinbase: 0.0032% (p99 0.0052%, success 100.0%, sample 5760)
2. OKX: 0.0041% (p99 0.0077%, success 100.0%, sample 2880)
3. Gate: 0.0045% (p99 0.0044%, success 100.0%, sample 5760)
4. Paradex: 0.0054% (p99 0.0059%, success 100.0%, sample 2880)
5. Bybit: 0.0054% (p99 0.013%, success 100.0%, sample 2880)
6. KuCoin: 0.0060% (p99 0.0045%, success 100.0%, sample 5760)
7. Bitget: 0.0072% (p99 0.0075%, success 100.0%, sample 5760)
8. MEXC: 0.0079% (p99 0.020%, success 100.0%, sample 5760)
9. Aster: 0.0081% (p99 0.010%, success 100.0%, sample 2880)
10. Binance: 0.0084% (p99 0.011%, success 100.0%, sample 2880)
11. Lighter: 0.0099% (p99 0.011%, success 100.0%, sample 5760)
12. Kraken: 0.015% (p99 0.034%, success 100.0%, sample 5760)
13. Hyperliquid: 0.018% (p99 0.012%, success 100.0%, sample 2880)
14. Polymarket: 0.019% (p99 0.015%, success 100.0%, sample 2880)
15. dYdX v4: 0.021% (p99 0.049%, success 100.0%, sample 2880)

**Methodology**:
- Young venues read artificially stable at first: a venue whose funding has not moved since listing (Polymarket perps launched 2026-07-08 with a constant default rate) shows a stddev near zero until real funding history accrues. Read the sample count next to the rank.
- 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 97 ms (p50, 24h) on Fastest free Ethereum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 97 ms (p99 1.44 s, success 99.7%, sample 4312.72)
2. dRPC: 136 ms (p99 332 ms, success 92.2%, sample 4298.71)
3. Nodies: 184 ms (p99 532 ms, success 100.0%, sample 4323.71)
4. Tenderly: 249 ms (p99 311 ms, success 100.0%, sample 4313.71)
5. MeowRPC: 272 ms (p99 495 ms, success 99.9%, sample 4318.71)
6. Lava: 381 ms (p99 2.35 s, success 98.9%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 6 no-key public-read endpoints (PublicNode, dRPC, Tenderly, Nodies, Lava, MeowRPC). Cloudflare removed (persistent JSON-RPC -32603). MEV-protection RPCs (Flashbots, MEV Blocker, Blink, bloXroute) share this probe methodology but score on [mev-protect-rpc](/benchmarks/mev-protect-rpc), because their SLA optimises for send-tx privacy, not read speed.

## 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 86 ms (p50, 24h) on Fastest free Arbitrum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 86 ms (p99 621 ms, success 100.0%, sample 4310.71)
2. Nodies: 179 ms (p99 348 ms, success 100.0%, sample 4324.71)
3. Lava: 239 ms (p99 1.93 s, success 98.0%, sample 4298.71)
4. Tenderly: 243 ms (p99 297 ms, success 100.0%, sample 4319.71)
5. Arbitrum: 252 ms (p99 418 ms, success 100.0%, sample 4323.71)
6. MeowRPC: 275 ms (p99 495 ms, success 97.0%, sample 4318.71)
7. dRPC: 355 ms (p99 1.69 s, success 56.7%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 7 no-key endpoints (PublicNode, dRPC, 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 95 ms (p50, 24h) on Fastest free Base RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 95 ms (p99 3.21 s, success 99.7%, sample 4308.71)
2. dRPC: 167 ms (p99 506 ms, success 73.7%, sample 4309.71)
3. Tenderly: 246 ms (p99 452 ms, success 100.0%, sample 4312.71)
4. Base: 258 ms (p99 386 ms, success 100.0%, sample 4324.71)
5. Nodies: 268 ms (p99 583 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 5 no-key endpoints (PublicNode, dRPC, Tenderly, Nodies, Base). Blink (formerly Merkle) was delisted 2026-07: its gateway does not serve `eth_getBlockByNumber`, the anti-cache probe this cluster standardized on, so it cannot be measured on equal terms. 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 84 ms (p50, 24h) on Fastest free Optimism RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 84 ms (p99 450 ms, success 100.0%, sample 4311.71)
2. dRPC: 165 ms (p99 337 ms, success 71.9%, sample 4323.71)
3. Tenderly: 244 ms (p99 343 ms, success 100.0%, sample 4316.71)
4. Nodies: 271 ms (p99 857 ms, success 100.0%, sample 4324.71)
5. Optimism: 334 ms (p99 409 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 5 no-key endpoints (PublicNode, dRPC, 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 91 ms (p50, 24h) on Fastest free Avalanche RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 91 ms (p99 408 ms, success 100.0%, sample 4314.71)
2. Avalanche: 176 ms (p99 328 ms, success 100.0%, sample 4323.71)
3. dRPC: 196 ms (p99 421 ms, success 91.9%, sample 4305.71)
4. Tenderly: 334 ms (p99 400 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Avalanche). Nodies was delisted 2026-07 when its Avalanche endpoint moved behind a paid plan. 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: Binance leads rpc latency at 74 ms (p50, 24h) on Fastest free BNB Chain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Binance: 74 ms (p99 365 ms, success 100.0%, sample 4316.71)
2. PublicNode: 95 ms (p99 4.23 s, success 98.3%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 4 no-key endpoints (PublicNode, dRPC, Nodies, Binance). Blink (formerly Merkle) was delisted 2026-07: its gateway does not serve `eth_getBlockByNumber`, the anti-cache probe this cluster standardized on, so it cannot be measured on equal terms. 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 12 ms (p50, 24h) on Fastest free Polygon RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 12 ms (p99 387 ms, success 100.0%, sample 4301.71)
2. PublicNode: 89 ms (p99 2.78 s, success 99.4%, sample 4322.71)
3. Tenderly: 335 ms (p99 417 ms, success 100.0%, sample 4303.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 4 no-key endpoints (PublicNode, dRPC, 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 85 ms (p50, 24h) on Fastest free Linea RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 85 ms (p99 307 ms, success 100.0%, sample 4308.71)
2. dRPC: 110 ms (p99 347 ms, success 91.4%, sample 4306.71)
3. Tenderly: 332 ms (p99 417 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 3 no-key endpoints (PublicNode, dRPC, 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 91 ms (p50, 24h) on Fastest free Scroll RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 91 ms (p99 546 ms, success 100.0%, sample 4319.71)
2. dRPC: 203 ms (p99 432 ms, success 92.0%, sample 4316.71)
3. Tenderly: 332 ms (p99 422 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 3 no-key endpoints (PublicNode, dRPC, 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: dRPC leads rpc latency at 19 ms (p50, 24h) on Fastest free Mantle RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 19 ms (p99 494 ms, success 92.7%, sample 4304.71)
2. PublicNode: 83 ms (p99 628 ms, success 100.0%, sample 4324.71)
3. Tenderly: 334 ms (p99 413 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 3 no-key endpoints (PublicNode, dRPC, Tenderly). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Best DEX for a $BOT market order, live slippage ranked

- Category: Trading
- Metric: Effective slippage (bps)
- Page: https://openchainbench.com/benchmarks/perp-execution-quality
- JSON: https://openchainbench.com/api/stat/perp-execution-quality
- Status: live
- Headline: Hyperliquid leads effective slippage at 0.26% (24h avg) on Best DEX for a $BOT market order, live slippage ranked.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.26% (p99 0.38%, success 99.2%, sample 715)
2. Lighter: 4.61% (p99 7.24%, success 100.0%, sample 717)

**Methodology**:
- Cadence: every 30 seconds, in parallel across both venues, 10 second timeout per fetch.
- Lighter: `GET https://mainnet.zklighter.elliot.ai/api/v1/orderBookOrders?market_id=185&limit=100` returns the top-100 asks and bids for the $BOT perp market.
- Hyperliquid HIP-3: `POST https://api.hyperliquid.xyz/info {"type":"l2Book","coin":"xyz:BOT"}` returns the L2 book for the xyz-deployed BOT perp under HIP-3 permissionless listings.
- Mid price: (best_bid + best_ask) / 2 from the top of each book, per tick, per venue.
- Walk: for each USD notional bucket, iterate the sorted side, consuming `min(level_notional_usd, remaining_target_usd)` until target is filled; size-weighted average execution price is target_usd / total_base_filled.
- Slippage bps: (avg_execution_price - mid) / mid x 10000 on the buy side, mirrored on the sell side, sign-normalized so every published value represents cost to the trader.
- Buckets published: $100, $1,000, $5,000, $10,000, $25,000, $50,000, $100,000, $500,000. Both sides (buy, sell).
- Depth fallback: if the visible book does not cover 99% of the requested size, the slippage series for that (venue, side, size) is dropped for that tick and `perp_execution_max_fillable_usd{side}` reports the ceiling instead.
- Headline. avg_over_time of `perp_execution_slippage_bps{asset="BOT", side="buy", size_usd="5000"}` over 24h, per venue. A one-print spike does not move the ranking.
- Failures. A venue that errors or times out drops its `perp_execution_health` to 0 and increments `perp_execution_fetch_errors_total{error_type}`; the leaderboard tags it as stale.
- CEX venues are intentionally out of scope. Traders comparing against a Binance or Bybit fill should read DefiLlama for the CEX-side audit; the DEX bench does not aggregate what it cannot orderbook-walk from a public endpoint.

## 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 90 ms (p50, 24h) on Fastest free Sonic RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 90 ms (p99 313 ms, success 100.0%, sample 4303.71)
2. dRPC: 196 ms (p99 374 ms, success 93.1%, sample 4302.71)
3. Sonic Labs: 237 ms (p99 272 ms, success 100.0%, sample 4324.71)
4. Tenderly: 333 ms (p99 404 ms, success 100.0%, sample 4303.71)
5. Lava: 408 ms (p99 2.77 s, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 5 no-key endpoints (PublicNode, dRPC, 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 87 ms (p50, 24h) on Fastest free Gnosis RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 87 ms (p99 344 ms, success 100.0%, sample 4316.71)
2. dRPC: 168 ms (p99 628 ms, success 92.4%, sample 4317.71)
3. Tenderly: 333 ms (p99 409 ms, success 100.0%, sample 4314.71)
4. Gnosis: 338 ms (p99 1.30 s, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Gnosis). Nodies was delisted 2026-07 when its Gnosis endpoint moved behind a paid plan. 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 96 ms (p50, 24h) on Fastest free Celo RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 96 ms (p99 858 ms, success 100.0%, sample 4316.71)
2. Celo (Forno): 189 ms (p99 247 ms, success 100.0%, sample 4314.71)
3. dRPC: 214 ms (p99 1.12 s, success 81.5%, sample 4315.71)
4. Tenderly: 334 ms (p99 389 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 4 no-key endpoints (PublicNode, dRPC, 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: dRPC leads rpc latency at 250 ms (p50, 24h) on Fastest free Moonbeam RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 250 ms (p99 1.48 s, success 91.7%, sample 4310.71)
2. Tenderly: 332 ms (p99 402 ms, success 100.0%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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.

## 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 83 ms (p50, 24h) on Fastest free Unichain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 83 ms (p99 323 ms, success 100.0%, sample 4316.71)
2. dRPC: 165 ms (p99 594 ms, success 92.9%, sample 4297.71)
3. Unichain: 248 ms (p99 301 ms, success 100.0%, sample 4308.71)
4. Tenderly: 333 ms (p99 374 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 4 no-key endpoints (PublicNode, dRPC, 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 2 ms, success 100.0%, sample 4311.94)
2. PublicNode: 89 ms (p99 416 ms, success 100.0%, sample 4310.94)
3. dRPC: 189 ms (p99 535 ms, success 92.8%, sample 4311.93)
4. Tenderly: 327 ms (p99 394 ms, success 100.0%, sample 4323.94)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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 138 ms (p50, 24h) on Fastest free Taiko RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 138 ms (p99 595 ms, success 100.0%, sample 4314.71)
2. Taiko: 225 ms (p99 894 ms, success 100.0%, sample 4302.71)
3. dRPC: 236 ms (p99 288 ms, success 82.5%, sample 4319.71)
4. Tenderly: 331 ms (p99 382 ms, success 100.0%, sample 4311.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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 191 ms (p50, 24h) on Fastest free Berachain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Berachain: 191 ms (p99 226 ms, success 100.0%, sample 4316.71)
2. dRPC: 237 ms (p99 288 ms, success 91.8%, sample 4302.71)
3. PublicNode: 245 ms (p99 601 ms, success 100.0%, sample 4315.71)
4. Tenderly: 331 ms (p99 386 ms, success 100.0%, sample 4313.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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 169 ms (p50, 24h) on Fastest free zkSync Era RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 169 ms (p99 631 ms, success 92.6%, sample 4318.71)
2. zkSync: 227 ms (p99 895 ms, success 99.7%, sample 4316.71)
3. Tenderly: 335 ms (p99 393 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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: 3 no-key endpoints (dRPC, 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 26 ms (p50, 24h) on Fastest free Cronos RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Cronos: 26 ms (p99 58 ms, success 100.0%, sample 4307.71)
2. PublicNode: 100 ms (p99 450 ms, success 100.0%, sample 4304.71)
3. dRPC: 257 ms (p99 312 ms, success 93.1%, sample 4297.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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.

## 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 23 ms (p50, 24h) on Fastest free Fraxtal RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Fraxtal: 23 ms (p99 131 ms, success 100.0%, sample 4319.71)
2. dRPC: 169 ms (p99 621 ms, success 92.8%, sample 4303.71)
3. PublicNode: 252 ms (p99 634 ms, success 100.0%, sample 4323.71)
4. Tenderly: 334 ms (p99 458 ms, success 100.0%, sample 4320.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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 14 ms (p50, 24h) on Fastest free Soneium RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Soneium: 14 ms (p99 29 ms, success 100.0%, sample 4306.71)
2. PublicNode: 85 ms (p99 263 ms, success 100.0%, sample 4321.71)
3. dRPC: 202 ms (p99 858 ms, success 92.1%, sample 4295.71)
4. Tenderly: 335 ms (p99 438 ms, success 100.0%, sample 4313.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- 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.

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

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

**Rankings (p50, 24h):**
1. Monad: 1 ms (p99 3 ms, success 100.0%, sample 4307.94)
2. OnFinality: 123 ms (p99 2.40 s, success 100.0%, sample 4320.94)
3. dRPC: 187 ms (p99 350 ms, success 98.2%, sample 4312.94)
4. Tenderly Gateway: 328 ms (p99 372 ms, success 100.0%, sample 4321.94)

**Methodology**:
- Cadence: every 60 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 via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 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.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain. Every endpoint on this page was live-verified (eth_chainId match + anti-cache probe) before inclusion on 2026-07-08.
- Chain scope: every query on this page is pinned to chain="monad" (chain id 143, mainnet since November 2025). Provider coverage: 5 no-key endpoints (Monad Official, dRPC, Tenderly Gateway, bloXroute, OnFinality). Exclusions follow the cluster-wide rules documented on the parent benchmark.

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

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

**Rankings (p50, 24h):**
1. MegaETH Official: 20 ms (p99 70 ms, success 100.0%, sample 4314.71)
2. dRPC: 170 ms (p99 271 ms, success 92.0%, sample 4305.71)
3. Tenderly Gateway: 333 ms (p99 392 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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 via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 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.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain. Every endpoint on this page was live-verified (eth_chainId match + anti-cache probe) before inclusion on 2026-07-08.
- Chain scope: every query on this page is pinned to chain="megaeth" (chain id 4326, mainnet since February 2026). Provider coverage: 3 no-key endpoints (MegaETH Official, dRPC, Tenderly Gateway). Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Fastest MEV protection RPC, live wallet latency and method coverage

- Category: RPCs
- Metric: Wallet call latency (ms)
- Page: https://openchainbench.com/benchmarks/mev-protect-rpc
- JSON: https://openchainbench.com/api/stat/mev-protect-rpc
- Status: live
- Headline: bloXroute Protect leads wallet call latency at 8 ms (p50, 24h) on Fastest MEV protection RPC, live wallet latency and method coverage.

**Rankings (p50, 24h):**
1. bloXroute Protect: 8 ms (p99 9 ms, success 98.7%, sample 60280.2)
2. 48 Club Privacy RPC: 22 ms (p99 25 ms, success 100.0%, sample 30141)
3. PancakeSwap MEV Guard: 26 ms (p99 33 ms, success 100.0%, sample 30140.9)
4. MEV Blocker: 50 ms (p99 360 ms, success 100.0%, sample 30141.3)
5. Blink: 100 ms (p99 109 ms, success 96.6%, sample 90423.5)
6. Flashbots Protect: 101 ms (p99 110 ms, success 69.4%, sample 30146.1)
7. BlockSec Anti-MEV: 108 ms (p99 114 ms, success 100.0%, sample 60280.1)

**Methodology**:
- Providers measured, one row per (provider, chain), all keyless and live-verified 2026-07-12. Ethereum cohort: Flashbots Protect (rpc.flashbots.net), MEV Blocker (rpc.mevblocker.io), Blink formerly Merkle (ethereum.blinklabs.xyz), bloXroute Protect (eth-protect.rpc.blxrbdn.com), BlockSec Anti-MEV (eth.rpc.blocksec.com).
- Base cohort: Blink (base.merkle.io) alone. No other MEV-protect gateway exposes a keyless Base endpoint today; Flashbots and MEV Blocker are Ethereum-only by design and base.rpc.blxrbdn.com is plain RPC, not documented as Protect.
- BSC cohort: Blink (bsc.merkle.io), bloXroute Protect (bsc.rpc.blxrbdn.com), 48 Club Privacy RPC (rpc.48.club), PancakeSwap MEV Guard (bscrpc.pancakeswap.finance, powered by 48 Club), BlockSec (bsc.rpc.blocksec.com).
- Exclusions: SecureRPC probed dead 2026-07-10. Alchemy MEV Protect and GetBlock protected endpoints are key-gated. Blink's Ethereum row uses the blinklabs.xyz host because the legacy eth.merkle.io alias rate-limits harder; on Base and BSC the merkle.io hosts are Blink's only keyless surface (base/bsc.blinklabs.xyz do not resolve as of 2026-07-12).
- Chain dimension: the tabs pin every query to one chain. The All chains headline averages each provider over the chains it actually serves, the same convention as the rpc-capabilities cluster; the Chains covered panel shows the multi-chain footprint explicitly.
- Method set: eth_chainId, eth_blockNumber, eth_gasPrice, eth_getBalance, eth_call (USDC balanceOf), eth_estimateGas, eth_feeHistory. One request per method per tick, 1.5s apart, rotating request ids against body-keyed edge caches.
- Cadence: every 60 seconds per region (us-east, eu-west, sgp), 7 requests per gateway per tick, rows probed in parallel so each gateway still sees one request per 1.5s. Deliberately polite: these gateways rate-ban aggressive callers.
- Headline: median latency across the methods the provider served that tick, aggregated over 24h with quantile_over_time. A rejected method does not poison the latency; it lowers the coverage panel instead.
- Coverage: mev_rpc_methods_supported counts the wallet methods served on the last tick (max 7) per chain. Flashbots rejects eth_call on the public endpoint; Blink blocks full-node reads like eth_getBlockByNumber, which keeps it off the general RPC benches but not off this one.
- Out of scope, disclosed: inclusion rate, refund economics and sandwich protection efficacy are the write path and require funded transactions. See the arXiv study Private MEV Protection RPCs (2505.19708) for a one-off execution-quality comparison.
- Success rate counts transport failures only (timeouts, throttling, network); a method a gateway refuses by policy is a coverage gap shown in the coverage panel, not an outage. Failures increment mev_rpc_call_total{result}; the gauge keeps its last value so the chart shows the outage in the success column rather than a fake zero.
- Scope discipline: this bench is deliberately kept off the /rpc chain leaderboard. The per-chain RPCs cluster (ethereum-rpc, base-rpc, bsc-rpc) ranks public read gateways on eth_getBlockByNumber latency. Ranking Flashbots Protect against PublicNode on that axis would flatter the wrong SLA: Flashbots is optimised for send-tx privacy, PublicNode for read speed. MEV protect gateways live here, ranked against each other on the read-path wallets actually feel.

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

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

**Rankings (p50, 24h):**
1. Solana: 12 ms (p99 568 ms, success 100.0%, sample 4319.71)
2. PublicNode: 92 ms (p99 5.42 s, success 96.4%, sample 4302.71)
3. Solana Vibe Station: 220 ms (p99 688 ms, success 100.0%, sample 4321.71)
4. Lava: 315 ms (p99 2.01 s, success 99.4%, sample 4301.71)
5. LeoRPC: 635 ms (p99 2.29 s, success 82.1%, sample 4302.71)

**Methodology**:
- Cadence: every 60 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 via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"getSlot","params":[{"commitment":"processed"}]}`. Plain HTTP POST, identical for every endpoint, no API key in any request; the rotating id defeats body-keyed edge caches.
- Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram, percentiles computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok`, `http_err`, `jsonrpc_err`, `stale` (more than 300 slots, about 2 minutes, behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- No archive-depth audit on Solana: the EVM chains probe `eth_getBalance` at historical heights, which has no equivalent on public Solana endpoints. Disclosed rather than faked.
- LeoRPC disclosure: the endpoint uses a publicly documented FREE query key (solana.leorpc.com/?api_key=FREE). It is admitted as keyless in practice since no signup is required; flagged here for transparency.
- This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; identical harness and exclusion rules.
- Chain scope: every query on this page is pinned to chain="solana". Provider coverage: 5 no-key endpoints (Solana Labs, PublicNode, Lava, LeoRPC, Solana Vibe Station). Excluded with verified refusals 2026-07-12: dRPC (Solana is paid-tier only), Ankr (403 key required), OnFinality (shared quota permanently 429), BlockPI (no public URL), Triton free.rpcpool.com (403), Blast API + ExtrNode + AllThatNode (DNS dead), OMNIA (521), Helius + Shyft + BlockEden (key-gated).

## Tokenized stock price accuracy, live onchain vs Nasdaq across 11 equities

- Category: RWA
- Metric: Price deviation (bps)
- Page: https://openchainbench.com/benchmarks/tokenized-stock-peg
- JSON: https://openchainbench.com/api/stat/tokenized-stock-peg
- Status: live
- Headline: NVDA leads price deviation at 0.020% (24h avg) on Tokenized stock price accuracy, live onchain vs Nasdaq across 11 equities.

**Rankings (p50, 24h):**
1. NVDA: 0.020% (p99 0.020%, success 100.0%, sample 33264)
2. META: 0.42% (p99 0.42%, success 100.0%, sample 33264)
3. AAPL: 0.52% (p99 0.52%, success 100.0%, sample 33264)
4. MU: 1.09% (p99 1.09%, success 100.0%, sample 33264)
5. AMD: 1.11% (p99 1.11%, success 100.0%, sample 33264)
6. PLTR: 1.20% (p99 1.20%, success 100.0%, sample 33264)

**Methodology**:
- Onchain leg: one JSON-RPC batch per tick to StateView (0xF3334192D15450CdD385c8B70e03f9A6bD9E673b) getSlot0(poolId) on the Uniswap v4 PoolManager singleton, keyless against the official Robinhood Chain RPC. sqrtPriceX96 converts to USDG per share with the per-pool currency ordering and the USDG 6 vs stock 18 decimal gap (factor 1e12).
- Reference leg: Yahoo Finance v8 spark batch, one call for all 11 symbols per tick, browser User-Agent, no key. regularMarketPrice doubles as the last-close reference when the market is closed, which is exactly the weekend baseline.
- Market session labels: derived from Yahoo currentTradingPeriod epochs (pre / regular / post / closed), which Yahoo publishes holiday-aware, so the harness maintains no NYSE calendar. The headline ranking pins market_state="regular"; the closed series is the drift panel.
- Deviation: 10000 x |pool_price - reference_price| / reference_price, sampled every 60 seconds, quantiles over 24h via quantile_over_time.
- Cohort: the 11 official tokenized equities (name pattern <Company> * Robinhood Token, shared verified Stock implementation) whose USDG pool has real liquidity and swap history: NVDA, AAPL, GOOGL, TSLA, PLTR, META, AMD, MSFT, AMZN, SPY, MU. Pool fees range 0.3% to 2%.
- Excluded, with reasons: SPCX (SpaceX pool holds ~$196k but SpaceX is not listed, no reference price exists), SNDK and QQQ (pool depth under $2k, deviation would be noise), CRCL (pool at zero liquidity), ~80 other official tokens (issuer-seeded placeholder pools at 90-95% fee, zero swaps), HOOD (never issued onchain, all HOOD tokens on the chain are third-party spam).
- Thin liquidity is part of the story, not a defect: pool depths run $24k to $330k, so a single mid-size swap can move the onchain price meaningfully off the reference until arbitrage closes it. The bench measures how fast that closure actually happens.
- Reading grid: an AMM price can sit anywhere inside the pool's fee band without creating an arbitrage opportunity, so a 2% fee pool resting 150 bps off its reference is economically at equilibrium, not broken. Cross-symbol ranking therefore partly reflects each pool's fee tier (disclosed in every tag); the within-symbol trend over time is the purest signal.
- Quote-asset caveat: pool prices are denominated in USDG and compared against USD references. A USDG peg wobble would appear as a correlated deviation across all 11 symbols simultaneously, which is the signature to check before reading a broad move as tracking error.
- Caveats: the issuer can pause or blocklist a token (the harness drops the sample and lets the series age out rather than freezing), and the Stock contract carries a split multiplier; a corporate action can look like a one-day deviation spike until reconciled.

## xStocks price accuracy, live onchain vs Nasdaq across 12 equities on Solana

- Category: RWA
- Metric: Price deviation (bps)
- Page: https://openchainbench.com/benchmarks/xstocks-peg
- JSON: https://openchainbench.com/api/stat/xstocks-peg
- Status: live
- Headline: TSLAx leads price deviation at 0.0072% (24h avg) on xStocks price accuracy, live onchain vs Nasdaq across 12 equities on Solana.

**Rankings (p50, 24h):**
1. TSLAx: 0.0072% (p99 0.0072%, success 96.4%, sample 33263)
2. GOOGLx: 0.024% (p99 0.024%, success 96.6%, sample 33263)
3. NVDAx: 0.078% (p99 0.078%, success 100.0%, sample 33263)
4. QQQx: 0.18% (p99 0.18%, success 96.6%, sample 33263)
5. METAx: 0.18% (p99 0.18%, success 100.0%, sample 33263)
6. AMZNx: 0.30% (p99 0.30%, success 96.5%, sample 33263)
7. HOODx: 0.31% (p99 0.31%, success 96.6%, sample 33263)
8. COINx: 0.39% (p99 0.39%, success 96.6%, sample 33263)
9. AAPLx: 0.42% (p99 0.42%, success 100.0%, sample 33263)
10. SPYx: 0.52% (p99 0.52%, success 96.6%, sample 33263)
11. MSFTx: 0.67% (p99 0.67%, success 96.5%, sample 33263)
12. PLTRx: 0.74% (p99 0.74%, success 100.0%, sample 33263)

**Methodology**:
- Onchain leg: Jupiter lite-api swap quotes, keyless, both directions per symbol (sell 1 share to USDC, buy the proceeds back), spaced 1.1s apart, ~26s per sweep for 12 symbols. Price = mid of the two implied prices: an executable aggregated price across Raydium, Orca and every routed venue, not a single pool spot.
- Token-2022 correction: 7 of 12 xStocks mints carry a ScaledUiAmount multiplier (~1.0009 observed). One batched price/v3 call per tick supplies the live multiplier per mint (usdPrice over usdPricePrescaled), converting raw quote units to exactly one UI share. Ignoring it would bake a ~9bp systematic error into affected symbols.
- Reference leg: Yahoo Finance spark batch, one keyless call for all 12 underliers per tick, 1 minute candles; session labels (pre, regular, post, closed) derived from Yahoo currentTradingPeriod, holiday aware. HOODx maps to HOOD, SPYx to SPY, QQQx to QQQ, COINx to COIN.
- Deviation: 10000 x |executable mid - reference| / reference, quantiles over 24h via quantile_over_time. Headline pins market_state="regular"; the closed series is the weekend drift panel.
- Cohort: the 12 xStocks with verified Jupiter routes at under 2bp of 1-share price impact (2026-07-13): TSLAx, NVDAx, AAPLx, MSFTx, AMZNx, GOOGLx, METAx, HOODx, SPYx, QQQx, COINx, PLTRx. All mints 8 decimals, verified individually; counterfeit lookalike mints excluded by address allowlist.
- Round-trip honesty: the sell/buy spread observed at verification was ~11bp on TSLAx. Using the mid rather than one side keeps the fee component out of the deviation number; the spread itself is executable cost, not tracking error.
- Quote asset caveat: prices are in USDC against USD references. A USDC peg wobble would appear as a correlated deviation across all 12 symbols simultaneously.
- Cross-issuer reading: this bench shares its metric contract with the Robinhood Chain tokenized stock bench (issuer label). Same equity, same reference, two issuers: the pages are directly comparable, with the depth difference disclosed (Solana xStocks pools run 10x to 100x deeper).

## USDY NAV basis, live market price vs official redemption rate

- Category: RWA
- Metric: NAV basis (bps)
- Page: https://openchainbench.com/benchmarks/usdy-nav-basis
- JSON: https://openchainbench.com/api/stat/usdy-nav-basis
- Status: live
- Headline: Pyth market composite leads nav basis at 0.21% (24h avg) on USDY NAV basis, live market price vs official redemption rate.

**Rankings (p50, 24h):**
1. Pyth market composite: 0.21% (p99 0.24%, success 100.0%, sample 40310)
2. Orca (Solana): 0.22% (p99 0.23%, success 52.8%, sample 40310)

**Methodology**:
- NAV leg: the Pyth Hermes feed Crypto.USDY/USD.RR (the redemption rate Ondo publishes onchain), fetched keyless. The same Hermes call carries the Pyth USDY/USD market composite, which doubles as a venue row.
- Market leg, Orca: the USDY/USDC whirlpool on Solana (~$2.9M, the deepest genuine USDY pool anywhere), price decoded straight from getAccountInfo bytes (sqrtPrice u128 at offset 65, both mints 6 decimals). Keyless against a public RPC.
- Basis: signed, (market - NAV) / NAV x 10000. Negative = the market discounts the NAV. The ranking sorts by absolute basis; the sign is the story and both are displayed.
- Excluded, verified 2026-07-13: the Arbitrum Camelot USDY/USDC pool holds 232 USDY against 7M USDC, effectively drained, its stale price sitting ~345bps under NAV with near zero volume. Kept out of the ranking as the textbook example of why pool depth gates peg quality; revisited monthly.
- Also not measurable, disclosed: OUSG, BUIDL and BENJI are transfer-restricted mint/redeem instruments with no genuine open pools, so no market test of their NAV exists to publish.
- USDY is yield accruing: the redemption rate rises daily, so a naive USD peg comparison would show permanent drift. Comparing against the live RR feed removes that by construction.

## Tokenized stock weekend drift, how far each equity wanders Friday to Monday

- Category: RWA
- Metric: Weekend max drift (bps)
- Page: https://openchainbench.com/benchmarks/tokenized-stock-weekend-drift
- JSON: https://openchainbench.com/api/stat/tokenized-stock-weekend-drift
- Status: live
- Headline: AAPL leads weekend max drift at 0.58% (24h avg) on Tokenized stock weekend drift, how far each equity wanders Friday to Monday.

**Rankings (p50, 24h):**
1. AAPL: 0.58% (p99 0.59%, success 100.0%, sample 40311)
2. NVDA: 0.59% (p99 1.03%, success 100.0%, sample 40311)
3. META: 0.66% (p99 0.81%, success 100.0%, sample 40311)
4. AMD: 0.88% (p99 1.10%, success 100.0%, sample 40311)
5. PLTR: 0.89% (p99 1.69%, success 100.0%, sample 40311)
6. MU: 1.22% (p99 2.63%, success 100.0%, sample 40311)

**Methodology**:
- Data source: the tsp_deviation_bps series emitted by the tokenized-stock-peg harness with the label market_state="closed". No new probe; the metric is a recording rule on existing samples.
- Session windows come from Yahoo currentTradingPeriod (holiday aware), which the harness already labels; the closed state runs from post-market close (roughly 21:00 UTC) to the next regular open (roughly 13:30 UTC).
- Weekend max drift: max_over_time(tsp_deviation_bps{issuer="robinhood", market_state="closed"}[72h]), aggregated per calendar weekend and labeled with the ISO week. The 72h window covers all pre-market and after-hours slots on either side of the weekend, not just the 60h weekend gap.
- Cohort: the 11 tokenized equities measured by the tokenized stock peg bench (NVDA, AAPL, GOOGL, TSLA, PLTR, META, AMD, MSFT, AMZN, SPY, MU). Same pool addresses, same reference, same fee tiers.
- The measurement is a bound, not a fair value: an AMM can sit anywhere inside its fee band without creating arbitrage, so weekend drift on a 2 percent fee pool starts at 200 bps by construction. Read the drift number alongside the pool fee, disclosed on the tokenized-stock-peg page.
- Not a claim about corporate fair value: the reference is Friday close, not the theoretical opening indication. When earnings, dividends or macro events happen on the weekend, Monday open will differ from Friday close by the same amount whether the pool moved or not.

## Fastest Ethereum WebSocket newHeads push, live block-push lag across RPC providers

- Category: RPCs
- Metric: Block push lag (ms)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-ethereum
- JSON: https://openchainbench.com/api/stat/ws-head-latency-ethereum
- Status: live
- Headline: PublicNode leads block push lag at 0.4 ms (p50, 24h) on Fastest Ethereum WebSocket newHeads push, live block-push lag across RPC providers.

**Rankings (p50, 24h):**
1. PublicNode: 0.4 ms (p99 10.24 s, success 100.0%, sample 28653.7)
2. dRPC: 158 ms (p99 10.24 s, success 99.8%, sample 28583.4)
3. Tenderly: 2.68 s (p99 10.24 s, success 99.9%, sample 28612.1)

**Methodology**:
- Providers measured (keyless WebSocket endpoints): PublicNode (wss://ethereum-rpc.publicnode.com), dRPC (wss://eth.drpc.org), Tenderly (wss://mainnet.gateway.tenderly.co), Onfinality (wss://eth.api.onfinality.io/public-ws). Keyed providers (Alchemy, Infura, Chainstack, QuickNode) join the cohort when contributor keys are wired via WS_URL_<PROVIDER>_ETHEREUM env vars; the harness skips them cleanly when unset.
- Cohort saturation: Ankr, Blast, LlamaRPC, BlockPI, 1RPC, NodeReal and Omniatech all reject a keyless WebSocket handshake at the time of ship (verified 2026-07), which is why the keyless tier stops at four (PublicNode, dRPC, Tenderly, Onfinality).
- Chains: Ethereum (headline, all four providers compete), Base via newHeads and Solana via slotSubscribe as secondary cohorts. Headline queries on this page are pinned to chain=ethereum so the ranking never mixes block cadences.
- Race scoring: the first provider to deliver block N sets T0. Each provider's sample for block N is arrival(N) minus T0 in milliseconds. The cohort closes 5 seconds after the first arrival; a provider arriving later than that is scored as a missed block (ws_block_gap_total), not as a huge latency sample.
- Relative, not absolute: a single vantage point cannot separate its own network path from provider pipeline time, so we subtract the two arrivals over the same path instead. Consequence: the fastest provider reads ~0 by construction, and the honest readings are win rate, the trailers' lag distribution, and gap counts, not the leader's absolute number.
- Blocks where only one provider delivered within the window emit no lag samples and no win: a one-horse race carries no relative information. Gap counters still increment for live providers that missed the block.
- Connection discipline: one persistent WebSocket per (provider, chain), client ping every 30s, read deadline 60s, plus a 90s head watchdog that forces a reconnect when a provider keeps the socket heartbeat alive but silently drops the subscription (a failure mode we have observed in production on other benches). Reconnects use exponential backoff 2s to 60s and are counted in ws_reconnects_total.
- Coverage score: ws_head_blocks_seen_total per provider divided by the cohort maximum over the same 24h window, clamped to 1. A provider that pushes fast but skips blocks loses on this column rather than hiding in the latency percentiles.
- Aggregation: per-provider lag histogram with a sub-millisecond floor (0.5 ms bucket up through 10 s tail), p50/p90/p99 via histogram_quantile over the 24h rate. Duplicate announcements of the same block on one connection are dropped; per-provider liveness is exported as ws_health (1 = connected and delivered a message in the last 120s).
- Cheat vector disclosure: a provider could theoretically pre-announce heads it has not fully validated to win the race. We keyed the cohort on block number as pushed; hash-level cross-checking against a reference node is on the v2 list. Reading win rate together with the gap counter already flags a provider that pushes early but wrong (retracted heads show up as cohort inconsistencies and reorg noise).
- Vantage point: a single eu-west host. Geography moves absolute arrival times but affects all providers over the same path; still, a provider whose nearest edge is far from eu-west is disadvantaged, and a us-east probe is the planned second vantage before any cross-region claim is made.

## Most reliable free public RPC, correctness incidents across 7 EVM chains

- Category: RPCs
- Metric: Reliability incidents (count)
- Page: https://openchainbench.com/benchmarks/rpc-reliability
- JSON: https://openchainbench.com/api/stat/rpc-reliability
- Status: live
- Headline: Lava leads reliability incidents at 1 (24h) on Most reliable free public RPC, correctness incidents across 7 EVM chains.

**Rankings (p50, 24h):**
1. Lava: 1 (p99 105, success 99.4%, sample 174.035)
2. Base: 1 (p99 0, success 98.7%, sample 78.0158)
3. PublicNode: 14 (p99 51.1K, success 97.7%, sample 576.117)
4. Binance: 39 (p99 0, success 50.0%, sample 78.0158)
5. Nodies: 164 (p99 0, success 67.1%, sample 498.101)
6. dRPC: 177 (p99 0.083, success 69.3%, sample 576.117)

**Methodology**:
- Consensus lag: the bench-010 latency probe fetches the full latest header every 60 seconds per (provider, chain); its height and hash, previously discarded, feed this bench. rpc_consensus_lag_blocks is the gap between the provider's reported head and the highest head any probed provider reported for that chain (rolling max). Valid-but-stale responses still count as observations; failed probes delete the series so dead endpoints age out.
- Hash quorum: per chain, a height-to-hash vote map. When one hash at height H is backed by at least 2 providers AND strictly more than any competing hash, it is canonical; a provider that reported a different hash at H is counted in rpc_hash_mismatch_total, at most once per (provider, height). A 2-2 split, the signature of a live reorg, resolves to no quorum and counts nobody.
- Fixed-vector integrity, cadence: every 5 minutes ONE chain is checked, rotating through the 7 chains with a canonical high-traffic USDC deployment (Ethereum, Arbitrum, Optimism, Base, Polygon, BNB, Avalanche). Each provider on that chain gets 2 checks per round, so a single-chain provider accrues ~82 checks per day and a 7-chain provider ~575.
- Logs completeness vector: eth_getLogs for the chain's canonical USDC contract (Circle native deployments; Binance-peg on BNB) over a 10-block window ending at tip minus N. Returned log counts are compared across providers; deviation from the strict majority count increments rpc_logs_disagreement_total and books a disagree incident. Live calibration on Ethereum returned 1371 logs consistently on drpc, tenderly and blastapi over the same fixed range.
- Anti-gaming rotation: N rotates daily over {20, 30, 40, 50, 60} blocks, so a provider cannot special-case a published fixed range, and request ids rotate on every call (the same edge-cache defeat as the latency probe). All depths stay far inside non-archive territory, so a pruned-but-honest node is never penalized.
- State consistency vector: eth_getBalance of a fixed well-known address (the same Vitalik address the archive-depth probe uses) at the tip-minus-N block. The hex answer must be byte-identical across providers; divergence from the strict majority increments rpc_state_disagreement_total. Live calibration showed byte-identical balances across all responding providers at a fixed block.
- Errors are signal: rpc_integrity_check_total{result} is ok, error or disagree. error covers blocked methods (1RPC answers eth_getLogs with -32000), depth gating (PublicNode keyless regressed to under 150 blocks of archive depth in July 2026, returning -32602 asking for a personal token), and transport failures. The headline counts error and disagree alike: a method you cannot call is unreliable regardless of why.
- Headline: incidents per 24h = increase of integrity checks with result error or disagree, plus increase of hash mismatches, from the eu-west vantage. Raw counts, no weighting; the p90/p99 columns are consensus-lag quantiles in blocks, published as raw companion dimensions.
- Single-region disclosure: incidents are counted from the eu-west probe only. Correctness, unlike latency, is location-independent in principle, but every provider fronts with anycast, so what we audit is the serving cluster eu-west traffic lands on; a diverged cache in another region is invisible to this bench. The us-east and sgp replicas emit the same metrics for cross-checking on the time-series chart.
- Quorum honesty: strict plurality everywhere. Two agreeing providers outvote one dissenter; two against two resolves to no quorum and books nothing; a lone answer with no second opinion is unverifiable, not wrong, and books ok. Disagreement requires being outvoted by an established majority.
- Cohort: 12 keyless providers from the bench-010 audited matrix. Excluded: LlamaRPC (fully down, HTTP 521, already delisted from the harness), 1RPC (delisted 2026-07-09 at under 13 percent success; when probed live it also blocked eth_getLogs with -32000, exactly the incident class this bench counts), Ankr / NodeReal / GetBlock / Chainstack (key-gated). Avalanche's foundation endpoint is probed by the harness and visible on bench 010; it is left out here only to keep the cohort at 12.
- Provider matrix and vector addresses are documented in harnesses/rpc-capabilities/cmd/script/config.go and integrity.go; the harness is shared with bench 010, so both benches see the identical provider set and probe budget.

## Ethereum block builder market share

- Category: Trading
- Metric: Block share (24h) (pct)
- Page: https://openchainbench.com/benchmarks/evm-block-builders
- JSON: https://openchainbench.com/api/stat/evm-block-builders
- Status: live
- Headline: Titan leads block share (24h) at 45.2% (24h avg) on Ethereum block builder market share.

**Rankings (p50, 24h):**
1. Titan: 45.2% (p99 45.2%, success 100.0%, sample 3238.56)
2. Quasar: 21.7% (p99 21.7%, success 100.0%, sample 1557.27)
3. Eureka: 12.4% (p99 12.4%, success 100.0%, sample 888.154)
4. Vanilla: 9.38% (p99 9.38%, success 100.0%, sample 672.117)
5. BuilderNet: 6.91% (p99 6.91%, success 100.0%, sample 495.086)
6. Other: 2.53% (p99 2.53%, success 100.0%, sample 181.031)
7. Builder+: 1.23% (p99 1.23%, success 100.0%, sample 88.0153)
8. Bob The Builder: 0.56% (p99 0.56%, success 100.0%, sample 40.0069)
9. beaverbuild: 0.070% (p99 0.070%, success 100.0%, sample 5.00087)

**Methodology**:
- Source: keyless public Ethereum RPC (ethereum-rpc.publicnode.com by default, env-overridable). eth_getBlockByNumber(latest) every 12s, matching the mainnet slot time. Gaps between polls are backfilled by block number (capped at 10) so the counters see every block, not just the ones that happen to be head at poll time.
- Attribution: extraData hex is decoded to printable ASCII and matched, lowercase, against a curated substring table (titan, quasar, eureka, buildernet, beaverbuild, rsync, builder0x69, flashbots, bloxroute, builder+/btcs, penguinbuild and more). First match wins; most specific substrings are ordered first.
- Vanilla detection: empty extraData or execution-client default tags (geth, reth, nethermind, besu, erigon, go1.x, platform strings) count as builder=vanilla, meaning the proposer built the block locally instead of outsourcing to a builder. This row is the live self-built share of Ethereum.
- Unattributed handling: any non-empty tag not in the table counts as builder=other, increments ebb_unattributed_total, and logs the raw extraData string. The table grows from operator logs instead of silently under-counting, the bench 016 pattern.
- Self-labeling caveat: extraData is voluntary. A builder can rebrand, blank its tag, or impersonate another. The relay cross-check below is the independent signal; a large divergence between extraData share and relay-side delivered payloads would surface tag games.
- Relay cross-check: seven MEV-Boost relay data APIs (Flashbots, ultrasound, Agnostic, bloXroute max-profit, bloXroute regulated, Titan, Aestus) are polled keyless every 5 min via GET /relay/v1/data/bidtraces/proposer_payload_delivered?limit=50. Delivered payloads are counted per relay (ebb_relay_payloads_total), deduped per relay by slot high-water-mark. The same slot on multiple relays is normal: builders multi-home bids, so relay counters measure relay share, not a partition of blocks.
- Single vantage: one harness in one region observes the chain through one public RPC. Attribution is not latency-sensitive (extraData is consensus data, identical from every vantage), so single-vantage only affects liveness, which the health gauges expose.
- Companion L2 metrics: the same harness measures Arbitrum sequencer-feed soft-confirmation lag (ebb_arb_softconf_lag_milliseconds, feed arrival to public RPC visibility, offset derived at runtime) and Base flashblocks cadence plus flashblock-to-RPC lag (ebb_base_flashblock_interval_milliseconds, ebb_base_softconf_lag_milliseconds). These are per-chain, not per-builder, so this spec surfaces builder share only; the L2 lag series feed a future bench page.

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

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

**Rankings (p50, 24h):**
1. OnFinality: 59 ms (p99 2.14 s, success 100.0%, sample 4303.71)
2. Parity: 175 ms (p99 1.08 s, success 100.0%, sample 4302.71)
3. PublicNode: 255 ms (p99 639 ms, success 100.0%, sample 4311.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"chain_getHeader","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 40 relay blocks behind the cross-provider tip, roughly 4 minutes at Polkadot's ~6 s block time), `timeout`. Latency without reliability is a misleading ranking signal.
- No archive-depth loop on this chain. Polkadot's state model is accessed via `state_getStorage` keyed by a Blake2-hashed storage key rather than the EVM `eth_getBalance(address, height)` pattern, so the archive probe used on the EVM cluster is not applied here.
- No cross-provider hash quorum on this chain. `chain_getHeader` returns the parent-block hash rather than the current-block hash (the current hash is derived by Blake2 over the SCALE-encoded header). Bench 083's height-hash quorum check is therefore skipped for Polkadot; the same reliability signal is still captured via `ok` / `stale` classification against the rolling cross-provider tip.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="polkadot"`. Provider coverage at launch: 3 no-key endpoints (Parity official, OnFinality public gateway, PublicNode). Excluded by the launch audit: 1RPC filters `chain_getHeader` as "Not Allowed" on its privacy relay; Dwellir returned 503 during the audit sweep; Ankr paid Polkadot tier only; Chainstack key-gated; RadiumBlock requires a referral header; Grove and Thirdweb return invalid-chain or key-gated.

## Fastest Base WebSocket newHeads push, live block-push lag across RPC providers

- Category: RPCs
- Metric: Block push lag (ms)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-base
- JSON: https://openchainbench.com/api/stat/ws-head-latency-base
- Status: live
- Headline: PublicNode leads block push lag at 0.4 ms (p50, 24h) on Fastest Base WebSocket newHeads push, live block-push lag across RPC providers.

**Rankings (p50, 24h):**
1. PublicNode: 0.4 ms (p99 19 ms, success 100.0%, sample 172560)
2. dRPC: 84 ms (p99 10.24 s, success 99.9%, sample 172554)

**Methodology**:
- Providers measured (keyless WebSocket endpoints): PublicNode (wss://base-rpc.publicnode.com), dRPC (wss://base.drpc.org). Tenderly does not expose a keyless Base WebSocket path and is scoped out until a public gateway is announced. Keyed providers (Alchemy, Infura, Chainstack, QuickNode) join the cohort when contributor keys are wired via WS_URL_<PROVIDER>_BASE env vars.
- Cohort saturation: Blast, LlamaRPC, BlockPI, 1RPC, mainnet.base.org and Ankr all reject a keyless WebSocket handshake at the time of ship (verified 2026-07), which is why the keyless tier stops at two.
- Chain scope: every query on this page is pinned to chain="base". Base block cadence is 2 seconds, so a 24h window carries roughly 43000 samples per provider (versus ~7200 on Ethereum), well above the 7000 sample floor used by the parent bench.
- Race scoring: identical to the parent [ws-head-latency](https://openchainbench.com/benchmarks/ws-head-latency-ethereum) benchmark. First provider to deliver block N sets T0. Each provider's sample for block N is arrival(N) minus T0 in milliseconds. Cohort closes 5 seconds after the first arrival; late arrivals are scored as missed blocks via ws_block_gap_total rather than as huge latency samples.
- Relative, not absolute: subtraction of two arrivals over the same path removes vantage-point network latency. Consequence: the fastest provider reads near zero by construction. The honest readings are win rate, trailers' lag distribution, and gap counts.
- Aggregation: per-provider lag histogram with a sub-millisecond floor (0.5 ms bucket up through 10 s tail), p50/p90/p99 via histogram_quantile over the 24h rate. Coverage score = ws_head_blocks_seen_total divided by cohort maximum, clamped to 1. A provider that pushes fast but skips blocks loses on this column, not on the latency percentiles.
- Connection discipline: one persistent WebSocket per (provider, chain), client ping every 30s, read deadline 60s, 90s head watchdog forcing reconnect when a socket keeps the heartbeat alive but silently drops the subscription. Exponential backoff 2s to 60s on reconnect.
- Vantage point: a single eu-west host. Multi-region deployment is a follow-up on the parent bench roadmap; the same limitation and the reasoning behind it are documented there.

## Fastest Solana WebSocket slotSubscribe push, live slot-push lag across RPC providers

- Category: RPCs
- Metric: Slot push lag (ms)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-solana
- JSON: https://openchainbench.com/api/stat/ws-head-latency-solana
- Status: live
- Headline: Solana leads slot push lag at 0.3 ms (p50, 24h) on Fastest Solana WebSocket slotSubscribe push, live slot-push lag across RPC providers.

**Rankings (p50, 24h):**
1. Solana: 0.3 ms (p99 24 ms, success 75.0%, sample 622913)
2. PublicNode: 93 ms (p99 10.24 s, success 100.0%, sample 830561)

**Methodology**:
- Providers measured (keyless WebSocket endpoints): PublicNode (wss://solana-rpc.publicnode.com) and Solana Foundation (wss://api.mainnet-beta.solana.com). Keyed providers (Alchemy, Chainstack, Helius, QuickNode) join the cohort when contributor keys are wired via WS_URL_<PROVIDER>_SOLANA env vars.
- Cohort saturation: dRPC's free Solana tier explicitly disallows slotSubscribe ("method is not available on freetier") and the other public Solana WSS gateways audited (Blast, BlockPI, Ankr, extrnode, Chainstack public) all reject the handshake (verified 2026-07), which is why the keyless tier stops at two.
- Chain scope: every query on this page is pinned to chain="solana". Solana slot cadence is ~400ms, so a 24h window carries roughly 216000 samples per provider, an order of magnitude beyond the 7000 sample floor used across the head-lag cluster.
- RPC method: `slotSubscribe`, not `signatureSubscribe` or `logsSubscribe`. The notification payload includes the slot number and the parent slot; the harness dedupes on slot number and uses the first arrival per slot to define T0.
- Race scoring: identical to the parent [ws-head-latency](https://openchainbench.com/benchmarks/ws-head-latency-ethereum) benchmark, applied per slot instead of per block. First provider to deliver slot N sets T0. Each provider's sample for slot N is arrival(N) minus T0 in milliseconds. Cohort closes 5 seconds after the first arrival.
- Relative, not absolute: subtraction of two arrivals over the same path removes vantage-point network latency. Consequence: the fastest provider reads near zero by construction. The honest readings are win rate, trailers' lag distribution, and gap counts, not the leader's absolute number.
- Aggregation: per-provider lag histogram with a sub-millisecond floor (0.5 ms bucket up through 10 s tail), p50/p90/p99 via histogram_quantile over the 24h rate. Coverage score = ws_head_blocks_seen_total divided by cohort maximum, clamped to 1.
- Connection discipline: one persistent WebSocket per (provider, chain), client ping every 30s, read deadline 60s, 90s slot watchdog forcing reconnect when a socket keeps the heartbeat alive but silently drops the subscription. Exponential backoff 2s to 60s on reconnect.
- Vantage point: a single eu-west host. Multi-region deployment is a follow-up on the parent bench roadmap; the same limitation and reasoning are documented there.

## Which tokenized T-bill or yield fund actually pays what it promises

- Category: RWA
- Metric: Yield deviation (bps)
- Page: https://openchainbench.com/benchmarks/rwa-yield-accuracy
- JSON: https://openchainbench.com/api/stat/rwa-yield-accuracy
- Status: insufficient
- Headline: Which tokenized T-bill or yield fund actually pays what it promises. Awaiting first run.
- Insufficient samples to rank providers yet.

**Methodology**:
- Cohort: USDY (Ondo), USTB (Superstate), OUSG (Ondo), SyrupUSDC (Maple). BUIDL (BlackRock) and BENJI (Franklin Templeton) measurement is currently paused: BUIDL's distributor mints conflate new subscriptions with yield distribution, making the dividend-event model inaccurate; BENJI's Ethereum wrapper exposes no on-chain NAV function and Franklin has not yet published a machine-readable NAV endpoint.
- Delivered yield: derived per issuer from on-chain events. Rebase-model tokens compare totalSupply snapshots (t=now vs t=window ago). Dividend-model tokens sum USDC Transfer events from the treasury wallet to holders across the window. NAV-model tokens compare share NAV snapshots published by the issuer (fetched via the issuer's public endpoint, cross-checked with the smart contract's own price oracle where one exists).
- Promised yield: the APY the issuer publishes on its official dashboard or fund fact sheet. Sourced at least weekly from each issuer's own disclosures, with URL plus date logged in the harness config. When an issuer updates its stated APY, the change is tracked; historical values remain in Prometheus for the retention window.
- Windows: headline is 30-day rolling annualized. Also emitted: 7-day rolling (for volatility) and lifetime since token inception (for the honest cross-issuer comparison unaffected by short-window distribution cycles).
- Sign: delivered minus promised, in basis points. Negative means the token paid less than advertised over the window. Positive (rare) means more.
- Fees: promised APY is stated net of management fees. Delivered yield is measured on the same net basis. Any residual structural deviation typically reflects distribution timing (dividend-style tokens accrue daily but pay monthly), weekend accrual conventions (T-bills yield on business days only), or measurement methodology, not accounting.
- Cadence: on-chain reads every 60 seconds. Delivered-yield 30d rolling window is recomputed hourly (calculation is heavy, values move slowly). Promised-yield config file is reloaded every 60 seconds so a weekly update lands within a scrape cycle.
- Multi-chain tokens: USDY exists on Ethereum plus Solana, Aptos, Sui. V1 measures the Ethereum instance; V2 will surface per-chain deviations weighted by supply.
- Reproducibility: harness source at github.com/ChainBench/OpenChainBench/tree/main/harnesses/rwa-yield-accuracy. Every delivered-yield number derives from a public RPC read (contract address, event signature, block range documented). Every promised-yield number cites its source URL and date.

## DEX indexer with most blockchains, live coverage ranking

- Category: Aggregators
- Metric: DEX-indexed chains (count)
- Page: https://openchainbench.com/benchmarks/dex-network-coverage
- JSON: https://openchainbench.com/api/stat/dex-network-coverage
- Status: live
- Headline: GeckoTerminal leads dex-indexed chains at 250 (24h) on DEX indexer with most blockchains, live coverage ranking.

**Rankings (p50, 24h):**
1. GeckoTerminal: 250 (p99 250, success 100.0%, sample 250)
2. Codex: 122 (p99 122, success 100.0%, sample 122)
3. Sim by Dune: 64 (p99 64, success 100.0%, sample 64)
4. DexPaprika: 36 (p99 36, success 100.0%, sample 36)

**Methodology**:
- Source: each provider's public DEX-indexer networks endpoint.
- GeckoTerminal: GET /api/v2/networks (paginated, no auth). Chains where GeckoTerminal actively indexes DEX pools + trades.
- Codex: GraphQL `getNetworks` query at https://graph.codex.io/graphql with an official API key. Chains covered by Defined.fi's DEX data pipeline.
- DexPaprika: GET https://api.dexpaprika.com/networks (no auth). CoinPaprika's dedicated DEX tracker product, separate from the market-data API.
- Sim by Dune: 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 or slug; 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 free Osmosis RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Polkachu: 192 ms (p99 370 ms, success 100.0%, sample 4299.71)
2. LavenderFive: 197 ms (p99 384 ms, success 100.0%, sample 4303.71)
3. Osmosis Foundation: 207 ms (p99 381 ms, success 99.9%, sample 4322.71)
4. PublicNode: 246 ms (p99 600 ms, success 100.0%, sample 4303.71)
5. Imperator: 429 ms (p99 481 ms, success 65.5%, sample 4313.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare status query without touching a node.
- 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 40 blocks behind the cross-provider tip, roughly 4 minutes at Osmosis's ~6 s block time), `timeout`. Latency without reliability is a misleading ranking signal.
- No archive-depth loop on this chain. Cosmos SDK chains access historical state via ABCI queries keyed on module + KV-store, which does not map onto the flat `eth_getBalance(address, height)` probe cleanly.
- No cross-provider hash quorum on this chain at v1. Tendermint `status` does return `latest_block_hash` on the same block the height is reported for, so a quorum check is technically feasible, but the initial Osmosis add-on ships without it to keep the reliability change surface small; the hash normalisation across Cosmos chains will be validated before wiring bench 083 here.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="osmosis"`. Provider coverage at launch: 5 no-key endpoints (Osmosis Foundation, Polkachu, PublicNode, Imperator, LavenderFive).
- Excluded by the launch audit: Lava (osmosis.tendermintrpc.lava.build 403 without a key despite public branding), OnFinality (osmosis public gateway timing out at probe cadence), Numia (401), AutoStake (404), BlockApsis / WhisperNode / Enigma-Validator / StakeTown / reece.sh (connect errors, likely IPv6-only or geo-gated), Ankr + Chainstack (paid Cosmos tiers only).

## Fastest free Hyperliquid RPC, live no-key HyperEVM endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 14 ms (p99 88 ms, success 92.3%, sample 4304.71)
2. Hypurrscan: 74 ms (p99 225 ms, success 100.0%, sample 4313.71)
3. Hyperliquid Labs: 77 ms (p99 124 ms, success 98.4%, sample 4308.71)
4. Purroof Group: 175 ms (p99 184 ms, success 98.9%, sample 4311.71)
5. Stakely: 457 ms (p99 2.32 s, success 99.9%, sample 4300.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body , this is how the audit caught thirdweb's `Invalid chain` failure), `stale` (more than 25 blocks behind the cross-provider tip, roughly 50 seconds at HyperEVM's ~2 s block time), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="hyperliquid"`. Provider coverage at launch: 5 no-key endpoints (Hyperliquid Labs official, dRPC, Stakely, Purroof Group, Hypurrscan).
- Excluded by the launch audit: Alchemy demo path (rate-limited dead), thirdweb (`Invalid chain` on HyperEVM), Grove/Pocket public LB (requires an app id at the LB path), AllThatNode + Blast API + Chainstack + Gelato + Imperator HyperEVM paths (DNS-fail or 401 without a key), PublicNode (no HyperEVM subdomain yet). HyperEVM is a young chain (mainnet Feb 2025) so this list will shift quickly.

## Fastest free TRON RPC, live no-key JSON-RPC endpoint latency

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

**Rankings (p50, 24h):**
1. TronGrid: 13 ms (p99 102 ms, success 100.0%, sample 4324.71)
2. PublicNode: 154 ms (p99 293 ms, success 100.0%, sample 4306.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip, roughly 75 seconds at TRON's ~3 s block time), `timeout`. Latency without reliability is a misleading ranking signal.
- Surface scope: only the EVM-compatible JSON-RPC surface (`/jsonrpc` endpoints) is measured, because that is the path every cross-chain wallet, TronWeb / EVM bridge and arbitrage bot integrates against. The native TRON REST API (`wallet/getnowblock`, `wallet/triggersmartcontract`) is out of scope for this bench; a chain-specific `tron-rest` bench can be added later when there is clear demand from integrators using TronWeb directly.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="tron"`. Provider coverage: 2 no-key JSON-RPC endpoints (TronGrid, PublicNode). dRPC removed (method not available). The TRON JSON-RPC provider market is materially smaller than the EVM one; most TRON infra vendors expose only the native TRON REST API keyless, and gate the JSON-RPC path behind an API key.
- Excluded by the launch audit: dRPC (method not available), Ankr (key required on tron_jsonrpc path), Chainstack / NOWNodes / GetBlock / Tatum / BlockPI (key required on JSON-RPC path), OnFinality + Blast API + AllThatNode (no public TRON JSON-RPC gateway), Tron Foundation's rpc.trongrid.io (DNS dead; correct host is api.trongrid.io/jsonrpc).

## Fastest free Cosmos Hub RPC, live no-key Cosmos SDK endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/cosmos-hub-rpc
- JSON: https://openchainbench.com/api/stat/cosmos-hub-rpc
- Status: live
- Headline: Lava Network leads rpc latency at 71 ms (p50, 24h) on Fastest free Cosmos Hub RPC, live no-key Cosmos SDK endpoint latency.

**Rankings (p50, 24h):**
1. Lava Network: 71 ms (p99 1.50 s, success 100.0%, sample 4324.71)
2. Polkachu: 191 ms (p99 347 ms, success 99.7%, sample 4324.71)
3. LavenderFive: 196 ms (p99 428 ms, success 100.0%, sample 4309.71)
4. PublicNode: 202 ms (p99 623 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 40 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="cosmos-hub"`. Provider coverage at launch: 4 no-key endpoints (PublicNode, Polkachu, LavenderFive, Lava Network).

## Fastest free Injective RPC, live no-key Cosmos SDK endpoint latency

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

**Rankings (p50, 24h):**
1. Polkachu: 194 ms (p99 383 ms, success 100.0%, sample 4314.71)
2. LavenderFive: 203 ms (p99 608 ms, success 100.0%, sample 4322.71)
3. Injective Foundation: 238 ms (p99 258 ms, success 95.3%, sample 4308.04)
4. PublicNode: 258 ms (p99 636 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 40 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="injective"`. Provider coverage at launch: 4 no-key endpoints (Injective Foundation, PublicNode, Polkachu, LavenderFive).

## Fastest free Neutron RPC, live no-key Cosmos SDK endpoint latency

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

**Rankings (p50, 24h):**
1. Polkachu: 192 ms (p99 376 ms, success 100.0%, sample 4314.71)
2. LavenderFive: 196 ms (p99 510 ms, success 100.0%, sample 4307.71)
3. PublicNode: 411 ms (p99 699 ms, success 100.0%, sample 4320.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 40 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="neutron"`. Provider coverage at launch: 3 no-key endpoints (PublicNode, Polkachu, LavenderFive).

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

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

**Rankings (p50, 24h):**
1. World Chain: 7 ms (p99 17 ms, success 100.0%, sample 4316.71)
2. Tenderly Gateway: 243 ms (p99 283 ms, success 100.0%, sample 4307.71)
3. dRPC: 357 ms (p99 1.71 s, success 88.3%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="world-chain"`. Provider coverage at launch: 3 no-key endpoints (World Chain, dRPC, Tenderly Gateway).

## Fastest free Kaia RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Kaia Foundation: 74 ms (p99 107 ms, success 100.0%, sample 4321.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="kaia"`. Provider coverage: 1 no-key endpoint (Kaia Foundation). dRPC removed (500 paid plan only).

## Fastest free Ink RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. QuickNode: 168 ms (p99 200 ms, success 100.0%, sample 4324.71)
2. dRPC: 208 ms (p99 396 ms, success 92.7%, sample 4302.71)
3. Gelato: 223 ms (p99 688 ms, success 100.0%, sample 4305.71)
4. Tenderly Gateway: 244 ms (p99 290 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="ink"`. Provider coverage at launch: 4 no-key endpoints (Gelato, QuickNode, dRPC, Tenderly Gateway).

## Fastest free opBNB RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. BNB Chain Team: 74 ms (p99 285 ms, success 100.0%, sample 4324.71)
2. dRPC: 91 ms (p99 925 ms, success 92.3%, sample 4320.71)
3. PublicNode: 241 ms (p99 342 ms, success 100.0%, sample 4321.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="opbnb"`. Provider coverage at launch: 3 no-key endpoints (BNB Chain Team, PublicNode, dRPC).

## Fastest Wormhole VAA finalization by source chain, live latency

- Category: Bridges
- Metric: VAA finalization (ms)
- Page: https://openchainbench.com/benchmarks/wormhole-vaa-latency
- JSON: https://openchainbench.com/api/stat/wormhole-vaa-latency
- Status: live
- Headline: Sui leads vaa finalization at 3.40 s (p50, 24h) on Fastest Wormhole VAA finalization by source chain, live latency.

**Rankings (p50, 24h):**
1. Sui: 3.40 s (p99 12.33 s, success 100.0%, sample 160.028)
2. Monad: 3.50 s (p99 4.97 s, success 100.0%, sample 15.0026)
3. Polygon: 4.28 s (p99 9.96 s, success 100.0%, sample 266.046)
4. BNB Chain: 4.36 s (p99 14.18 s, success 100.0%, sample 526.091)
5. Avalanche: 6.45 s (p99 17.90 s, success 100.0%, sample 84.0146)
6. Berachain: 7.50 s (p99 9.95 s, success 100.0%, sample 1.00017)
7. Ink: 7.50 s (p99 9.95 s, success 100.0%, sample 2.00035)
8. Injective: 7.50 s (p99 9.95 s, success 100.0%, sample 2.00035)
9. Solana: 17.54 s (p99 23.98 s, success 100.0%, sample 5362.93)
10. Ethereum: 15.9 min (p99 19.9 min, success 100.0%, sample 1130.2)
11. Celo: 17.5 min (p99 19.9 min, success 100.0%, sample 3.00052)
12. Arbitrum: 17.9 min (p99 29.3 min, success 100.0%, sample 67.0116)
13. Unichain: 18.1 min (p99 29.5 min, success 100.0%, sample 10.0017)
14. Optimism: 20.0 min (p99 29.8 min, success 100.0%, sample 6.00104)
15. Base: 22.9 min (p99 30.0 min, success 100.0%, sample 136.024)

**Methodology**:
- Data source: `https://api.wormholescan.io/api/v1/vaas?pageSize=100`, the public wormholescan indexer of Wormhole VAAs. Polled every 60 seconds.
- Latency definition: `updatedAt − timestamp` from the VAA row. `timestamp` is the source-chain observation time (block containing the Wormhole message); `updatedAt` is the moment wormholescan first indexed the VAA as fully-signed by 13-of-19 Guardians.
- Dedupe: last 10 000 VAA ids kept in memory (rolling FIFO). Wormholescan returns ~100 VAAs/min sustained; 10k cache holds ~100 minutes of history, well above any poll interval.
- Bucketing: histogram with geometric buckets 2, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 300, 600 seconds.
- Guard: samples with `updatedAt − timestamp < 0` or `> 3600 s` are dropped (clock skew or backfilled VAAs whose `updatedAt` refers to a later re-index event).
- No canary transactions: this bench observes organic Wormhole traffic (thousands of VAAs/day). No wallet is funded, no gas is paid.
- Scope: 20 source chains Wormhole supports that are already tracked on OpenChainBench's chain registry. Chains with negligible VAA volume in a 24-hour window may appear with wide error bars or a low sample count.
- Destination chain is not measured: VAAs are relayed on demand once quorum is reached, so post-quorum latency is caller-driven (relayer choice, destination gas price, etc.) and not a property of Wormhole itself.

## Best DEX aggregator for quoting newly-launched tokens

- Category: Aggregators
- Metric: Quote coverage (pct)
- Page: https://openchainbench.com/benchmarks/token-quote-coverage
- JSON: https://openchainbench.com/api/stat/token-quote-coverage
- Status: live
- Headline: Jupiter leads quote coverage at 95.1% (24h avg) on Best DEX aggregator for quoting newly-launched tokens.

**Rankings (p50, 24h):**
1. Jupiter: 95.1% (p99 95.1%, success 95.1%, sample 1348.24)
2. KyberSwap: 94.0% (p99 94.0%, success 94.0%, sample 881.159)
3. Mobula: 92.1% (p99 92.1%, success 92.1%, sample 2229.4)

**Methodology**:
- Token discovery: five sources in parallel. (1) Dexscreener token-boosts: pump-fun (Solana) and pons (Robinhood). (2) Virtuals Protocol API: Virtuals agents on Base and Robinhood chain (virtuals). (3) GeckoTerminal BSC new_pools: four-meme. (4) GeckoTerminal Solana moonshot/pools: moonshot. (5) GeckoTerminal Solana meteora-dbc/pools: meteora-dbc. Boosted tokens from (1) are enriched via Dexscreener batch lookup to resolve dexId to venue labels.
- Quote probe: 1 USDC → token, fired in parallel to all in-scope providers with a 10s timeout. Input token is always USDC (native USDC on Solana and Base, bridged USDC.e on BNB). A probe is a coverage hit when the HTTP response is 2xx and the parsed outAmount field is a non-zero positive integer or decimal. All other outcomes (4xx, 5xx, no-route JSON, empty outAmount, timeout) record as misses.
- Aggregator endpoints: Jupiter lite-api.jup.ag/swap/v1/quote (Solana), Mobula /api/2/swap/quoting (EVM + Solana, API key), Relay api.relay.link/quote (EVM + Solana, no key), KyberSwap aggregator-api.kyberswap.com/{chain}/api/v1/routes (EVM only, no key), ParaSwap apiv5.paraswap.io/prices (EVM only, no key). Each adapter normalises chain identifiers, input/output decimals, and error response shapes before recording outcome.
- Jupiter strictMode=false: queried without the curated-token filter so Jupiter will attempt routing for any token with a discoverable on-chain pool, matching how most wallets call the API. strictMode=true would trivially exclude new tokens and defeat the purpose of the benchmark.
- Chain-scope enforcement: Jupiter probes Solana-only. KyberSwap and ParaSwap probe EVM only (Base, BNB, Robinhood). Mobula and Relay probe all four chains including Solana. Providers are never penalised for chains they do not support: null cells are excluded from cross-chain aggregates.
- Coverage metric: three counters per probe: attempts_total (every probe), api_ok_total (HTTP 200 received), success_total (HTTP 200 + outAmount > 0). Headline rate = success / attempts. Two derived slots: availability = api_ok / attempts; coverage_given_available = success / api_ok.
- Probe cadence and deduplication: each batch cycles through the current Dexscreener token-boosts feed. Tokens are not deduplicated across batches; the same token may appear in multiple 30-minute windows if it remains boosted. The score therefore reflects freshness of the aggregator's current routing graph, not historical coverage depth.
- Single origin: all probes originate from the eu-west OCB VPS. Regional latency is not a factor in this bench (the outcome is binary hit/miss, not latency). No region dimension in v1.

## Fastest Chainlink CCIP source chain by end-to-end delivery latency

- Category: Bridges
- Metric: CCIP delivery (ms)
- Page: https://openchainbench.com/benchmarks/chainlink-ccip-latency
- JSON: https://openchainbench.com/api/stat/chainlink-ccip-latency
- Status: live
- Headline: Solana leads ccip delivery at 1.6 min (p50, 24h) on Fastest Chainlink CCIP source chain by end-to-end delivery latency.

**Rankings (p50, 24h):**
1. Solana: 1.6 min (p99 8.0 min, success 100.0%, sample 80.014)
2. BNB Chain: 1.6 min (p99 4.9 min, success 100.0%, sample 129.022)
3. Monad: 1.7 min (p99 3.0 min, success 100.0%, sample 17.003)
4. Avalanche: 1.7 min (p99 3.0 min, success 100.0%, sample 17.003)
5. Polygon: 12.5 min (p99 14.9 min, success 100.0%, sample 16.0028)
6. Ethereum: 17.2 min (p99 28.0 min, success 100.0%, sample 178.031)
7. Optimism: 17.8 min (p99 29.7 min, success 100.0%, sample 19.0033)
8. Robinhood Chain: 18.8 min (p99 29.7 min, success 100.0%, sample 9.00156)
9. Arbitrum: 19.2 min (p99 29.8 min, success 100.0%, sample 32.0056)
10. Ink: 20.0 min (p99 59.8 min, success 100.0%, sample 4.00069)
11. Base: 25.8 min (p99 48.6 min, success 100.0%, sample 95.0165)

**Methodology**:
- Data source: `https://api.ccip.chain.link/v2/messages?limit=100`, the public CCIP Tools API. Polled every 60 seconds.
- Latency definition: `receiptTimestamp - sendTimestamp` from a CCIP message row with `status: SUCCESS`. `sendTimestamp` is the source-chain tx block time; `receiptTimestamp` is the destination-chain execution block time.
- Filter: only mainnet lanes are observed. Testnet messages (Ethereum Sepolia, TON Testnet, etc.) are dropped before histogram observation.
- Filter: only `status: SUCCESS` messages contribute to latency. In-flight statuses (SENT, SOURCE_FINALIZED, COMMITTED) are counted separately in `ccip_message_status_total` so a spike in COMMITTED without matching SUCCESS surfaces a stuck-execution incident.
- Dedupe: last 10 000 messageIds kept in memory (rolling FIFO). CCIP sustained rate is ~25 messages/minute network-wide, so the cache holds ~7h of history.
- Bucketing: histogram with buckets extending to 90 minutes (5 400 s). Wider than the Wormhole VAA bench because CCIP structurally waits for source-chain finality before its DON commits , Ethereum-source p99 legitimately reaches 25-30 min in adverse epochs.
- Guard: samples with `receiptTimestamp - sendTimestamp < 0` or `> 2h` are dropped (clock skew, stuck messages re-executed later, or timestamp typos).
- No canary transactions: this bench observes organic CCIP traffic (~500 mainnet messages/day across the top corridors). No wallet is funded, no gas is paid.
- Scope: CCIP-supported source chains with mainnet traffic in the observation window. Long-tail source chains (0G, ADI, Astar) will show wide error bars or a low sample count.
- Fair-comparison caveat: CCIP intentionally waits for source-chain finality before its DON commits, while some other cross-chain messaging networks (Wormhole, LayerZero) sign pre-finality. Comparing raw end-to-end numbers on ETH-source lanes is not apples-to-apples with those networks.

## Fastest LayerZero source chain by end-to-end message delivery

- Category: Bridges
- Metric: LayerZero delivery (ms)
- Page: https://openchainbench.com/benchmarks/layerzero-message-latency
- JSON: https://openchainbench.com/api/stat/layerzero-message-latency
- Status: live
- Headline: Monad leads layerzero delivery at 18.40 s (p50, 24h) on Fastest LayerZero source chain by end-to-end message delivery.

**Rankings (p50, 24h):**
1. Monad: 18.40 s (p99 18.0 min, success 100.0%, sample 400.069)
2. Arbitrum: 25.27 s (p99 27.8 min, success 100.0%, sample 1071.19)
3. Robinhood Chain: 25.43 s (p99 24.8 min, success 100.0%, sample 157.027)
4. Avalanche: 31.82 s (p99 10.0 min, success 100.0%, sample 100.017)
5. BNB Chain: 35.26 s (p99 4.6 min, success 100.0%, sample 2146.37)
6. Solana: 41.97 s (p99 3.3 min, success 100.0%, sample 360.063)
7. Celo: 43.64 s (p99 1.9 min, success 100.0%, sample 16.0028)
8. Unichain: 46.00 s (p99 29.4 min, success 100.0%, sample 28.0049)
9. Ink: 53.75 s (p99 59.5 min, success 100.0%, sample 23.004)
10. Base: 55.90 s (p99 2.8 min, success 100.0%, sample 1273.23)
11. Optimism: 1.2 min (p99 30.1 min, success 100.0%, sample 494.086)
12. Mantle: 1.3 min (p99 14.4 min, success 100.0%, sample 22.0038)
13. Polygon: 1.7 min (p99 18.3 min, success 100.0%, sample 269.047)
14. Linea: 4.0 min (p99 9.8 min, success 100.0%, sample 26.0045)
15. Ethereum: 4.1 min (p99 19.4 min, success 100.0%, sample 1407.24)
16. Scroll: 5.3 min (p99 14.1 min, success 100.0%, sample 19.0033)

**Methodology**:
- Data source: `https://scan.layerzero-api.com/v1/messages/latest?limit=150`, the public LayerZero Scan API. Polled every 60 seconds, 2 pages per poll (cursor via `nextToken`).
- Latency definition: `destination.tx.blockTimestamp - source.tx.blockTimestamp` from a LayerZero message row with `status.name: DELIVERED`. Both timestamps are Unix seconds from the source and destination chain blocks respectively.
- Filter: only `DELIVERED` messages contribute to latency. In-flight statuses (INFLIGHT, CONFIRMING, PAYLOAD_STORED, BLOCKED, FAILED) are counted separately in `lz_message_status_total` so a spike in CONFIRMING without matching DELIVERED surfaces a stuck-message incident.
- Dedupe: last 10 000 guids kept in memory (rolling FIFO). LayerZero sustained rate is ~4 messages/second network-wide, so the cache holds ~40 minutes of history.
- Bucketing: histogram with buckets 2, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 300, 600, 900, 1200, 1800 seconds (30 min ceiling).
- Guard: samples with delta `< 0` or `> 30 min` are dropped (clock skew, stuck messages re-executed later).
- No canary transactions: this bench observes organic LayerZero traffic (~250 messages/hour network-wide). No wallet is funded, no gas is paid.
- Scope: LayerZero-supported source chains with mainnet traffic in the observation window. LayerZero exposes many exotic chains (orderly, flare, ape, robinhood) that show up as separate rows once volume is non-trivial; low-traffic sources will have wide error bars.
- Fair-comparison caveat: LayerZero DVNs sign pre-finality by default, so end-to-end delivery excludes the source-chain finality wait that finality-aware networks (Chainlink CCIP, Axelar on Ethereum-source) impose. Comparing raw numbers to those on ETH-source lanes is not apples-to-apples.

## Fastest Hyperlane source chain by end-to-end message delivery

- Category: Bridges
- Metric: Hyperlane delivery (ms)
- Page: https://openchainbench.com/benchmarks/hyperlane-message-latency
- JSON: https://openchainbench.com/api/stat/hyperlane-message-latency
- Status: live
- Headline: Celo leads hyperlane delivery at 10.00 s (p50, 24h) on Fastest Hyperlane source chain by end-to-end message delivery.

**Rankings (p50, 24h):**
1. Celo: 10.00 s (p99 14.90 s, success 100.0%, sample 4.00069)
2. Polygon: 10.11 s (p99 24.79 s, success 100.0%, sample 139.024)
3. Arbitrum: 10.69 s (p99 38.64 s, success 100.0%, sample 356.062)
4. Mantle: 11.00 s (p99 29.10 s, success 100.0%, sample 12.0021)
5. Unichain: 13.33 s (p99 29.63 s, success 100.0%, sample 20.0035)
6. BNB Chain: 14.63 s (p99 57.23 s, success 100.0%, sample 185.032)
7. Ink: 17.81 s (p99 29.76 s, success 100.0%, sample 26.0046)
8. Sonic: 22.24 s (p99 41.70 s, success 100.0%, sample n/a)
9. Optimism: 23.62 s (p99 2.2 min, success 100.0%, sample 77.0136)
10. Base: 24.43 s (p99 59.12 s, success 100.0%, sample 395.069)
11. Solana: 44.21 s (p99 1.8 min, success 100.0%, sample 88.0155)
12. Avalanche: 45.00 s (p99 2.0 min, success 100.0%, sample 4.00069)
13. Linea: 1.0 min (p99 2.0 min, success 100.0%, sample 2.00035)
14. Ethereum: 4.0 min (p99 5.0 min, success 100.0%, sample 509.088)

**Methodology**:
- Data source: `https://api.hyperlane.xyz/v1/graphql` (Hasura), the public Hyperlane Explorer feed. Polled every 60 seconds, 100 messages per poll ordered by id DESC.
- Latency definition: `delivery_occurred_at - send_occurred_at` from a message row with `is_delivered: true`. Both timestamps come from the Mailbox contract events on the source and destination chains.
- Filter: only delivered messages contribute to latency. Undelivered messages (`is_delivered: false`) are counted separately in `hyperlane_message_undelivered_total` so relayer coverage gaps surface as a distinct signal rather than polluting the latency histogram.
- Dedupe: last 10 000 msg_ids kept in memory (rolling FIFO). Hyperlane sustained rate is ~150 messages/hour network-wide, so the cache holds ~66 hours of history.
- Bucketing: histogram with buckets 2, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 300, 600, 900, 1200, 1800 seconds (30 min ceiling).
- Guard: samples with delta `< 0` or `> 30 min` are dropped (clock skew or stuck messages re-delivered later).
- No canary transactions: this bench observes organic Hyperlane traffic. No wallet is funded, no gas is paid.
- Scope: Hyperlane-deployed source chains with mainnet traffic in the observation window. Non-EVM domains (Solana) map to their own row when Hyperlane exposes them under a numeric domain id.
- Relayer caveat: Hyperlane is permissionless; the observed latency is whichever relayer actually delivered the message. Applications choosing an under-served or misconfigured Interchain Security Module (ISM) will see structurally slower delivery. The bench reads practical UX, not a theoretical protocol floor.

## Fastest Axelar GMP source chain by end-to-end delivery

- Category: Bridges
- Metric: Axelar GMP delivery (ms)
- Page: https://openchainbench.com/benchmarks/axelar-gmp-latency
- JSON: https://openchainbench.com/api/stat/axelar-gmp-latency
- Status: live
- Headline: Avalanche leads axelar gmp delivery at 40.91 s (p50, 24h) on Fastest Axelar GMP source chain by end-to-end delivery.

**Rankings (p50, 24h):**
1. Avalanche: 40.91 s (p99 2.6 min, success 100.0%, sample 40.0069)
2. Osmosis: 46.21 s (p99 2.0 min, success 100.0%, sample 121.021)
3. BNB Chain: 47.78 s (p99 3.8 min, success 100.0%, sample 62.0108)
4. Polygon: 1.0 min (p99 2.0 min, success 100.0%, sample 56.0097)
5. Ethereum: 17.0 min (p99 25.2 min, success 100.0%, sample 143.025)
6. Arbitrum: 18.7 min (p99 29.7 min, success 100.0%, sample 19.0033)
7. Optimism: 25.0 min (p99 29.9 min, success 100.0%, sample 5.00085)
8. Base: 25.1 min (p99 33.9 min, success 100.0%, sample 61.0106)
9. Celo: 30.0 min (p99 39.8 min, success 100.0%, sample 2.00035)
10. Mantle: 55.0 min (p99 59.9 min, success 100.0%, sample 2.00036)

**Methodology**:
- Data source: `https://api.axelarscan.io/gmp/searchGMP` (POST), the public AxelarScan API. Polled every 60 seconds, 25 messages per poll (server-side cap).
- Two latency signals per message: `time_spent.call_confirm` (source-tx to Axelar validator quorum) and `time_spent.total` (source-tx to destination-chain execution). Both are pre-computed in seconds; the harness records both as separate Prometheus histograms.
- Filter: only `status: executed` messages contribute to latency histograms. Non-executed statuses (called, confirmed, approved, error) are counted separately in `axelar_gmp_status_total` so a spike in approved without executed surfaces a stuck-relayer incident.
- Dedupe: last 10 000 message ids kept in memory (rolling FIFO). Axelar GMP sustained rate is ~41 messages/hour network-wide, so the cache holds ~240 hours of history , never overflows in practice.
- Bucketing: histogram with buckets 2, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 300, 600, 900, 1200, 1800 seconds (30 min ceiling).
- Guard: samples with delta `< 0` or `> 30 min` are dropped (clock skew or stuck messages).
- Cosmos block-time quantisation: Axelar itself has 6-second Tendermint blocks, so sub-6s latencies always quantise to 0 or 6 seconds. This shows up as a visible floor on `call_confirm` for fast source chains and is a property of Axelar's own consensus, not our measurement.
- No canary transactions: this bench observes organic Axelar GMP traffic (Squid Router, ITS, Interchain Amplifier apps). No wallet is funded, no gas is paid.
- Scope: Axelar-supported source chains with mainnet traffic in the observation window. Axelar covers all major EVM L1s and L2s plus a large Cosmos set (Osmosis, Injective, Sei, Celestia, Kava) that no other bench in our cross-chain messaging cluster observes. Notable gap: Axelar mainnet does not support Solana yet.
- Fair-comparison caveat: Axelar validators wait for source-chain confirmations before signing (about 96 blocks / 20 minutes on Ethereum), so Ethereum-source lanes are structurally slower than pre-finality signers (LayerZero, Hyperlane) but still faster than Chainlink CCIP which waits for full Casper FFG finality.
- Coverage caveat: This is Axelar-exclusive Cosmos coverage. Comparing raw numbers to networks that only cover EVM (LayerZero, CCIP) is only meaningful on shared EVM corridors.

## Fastest free Sei RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Sei Labs: 94 ms (p99 1.05 s, success 94.0%, sample 4310.71)
2. Stakeme: 199 ms (p99 748 ms, success 85.7%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="sei"`. Provider coverage: 3 no-key endpoints. dRPC removed (500 persistent internal error).

## Fastest free Mode RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Mode Labs: 176 ms (p99 207 ms, success 100.0%, sample 4320.71)
2. dRPC: 389 ms (p99 1.06 s, success 85.6%, sample 4310.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="mode"`. Provider coverage at launch: 4 no-key endpoints.

## Fastest free Ronin RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Sky Mavis: 226 ms (p99 349 ms, success 100.0%, sample 4310.71)
2. Tenderly Gateway: 333 ms (p99 383 ms, success 100.0%, sample 4303.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="ronin"`. Provider coverage: 3 no-key endpoints. dRPC removed (500 persistent internal error).

## Fastest free Immutable zkEVM RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Immutable: 228 ms (p99 260 ms, success 100.0%, sample 4324.71)
2. Tenderly Gateway: 331 ms (p99 464 ms, success 100.0%, sample 4303.71)
3. dRPC: 345 ms (p99 532 ms, success 92.5%, sample 4322.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="immutable"`. Provider coverage at launch: 4 no-key endpoints.

## Polymarket WebSocket latency, live connection and update speed from 3 regions

- Category: Trading
- Metric: WS connect to snapshot (ms)
- Page: https://openchainbench.com/benchmarks/pm-ws-latency
- JSON: https://openchainbench.com/api/stat/pm-ws-latency
- Status: live
- Headline: Polymarket leads ws connect to snapshot at 2.08 s (p50, 24h) on Polymarket WebSocket latency, live connection and update speed from 3 regions.

**Rankings (p50, 24h):**
1. Polymarket: 2.08 s (p99 3.89 s, success 50.0%, sample 29.0072)
2. Kalshi: 5.0 min (p99 5.0 min, success 57.1%, sample 4.0006)

**Methodology**:
- Connect-to-snapshot: wall clock from websocket.Dial call start to receiving the first non-PONG frame. Covers TCP connection, TLS handshake, HTTP upgrade and the time the venue takes to deliver the first orderbook snapshot after receiving the subscribe message. Measured per reconnect event.
- Inter-arrival: wall clock between consecutive received data frames while the session is stable. Measures the velocity of the live feed, i.e. how often the venue pushes orderbook or price updates on a typical active market. Measured per message pair.
- Regions: us-east (Railway us-east4), eu-west (Railway europe-west4), sgp (Railway asia-southeast1). The Polymarket CLOB WS endpoint is globally distributed via Cloudflare, so regional differences reflect edge proximity and routing, not server capacity.
- Keepalive: a background goroutine sends the literal text PING every 10 seconds and the venue responds with PONG. Sessions that stop receiving data are detected by the reconnect logic on the next PING timeout. Disconnect rate is exported as a counter.
- Pin: the harness targets the same market used by the pm-rate-limits bench (highest 24h volume binary market with last trade price between 0.15 and 0.85), refreshed daily at 00:00 UTC. The WS client re-subscribes automatically when the pin changes.
- Metrics: pmapi_ws_connect_to_snapshot_seconds and pmapi_ws_update_interarrival_seconds histograms, labeled by venue, region and source. The pm-rate-limits harness runs the WS session alongside REST probes, sharing one Railway deployment per region. Kalshi note: its ticker channel is delta-only (no snapshot on subscribe), so connect-to-snapshot measures time to the first price change, which depends on market activity.
- Other venues: Kalshi WS (wss://api.elections.kalshi.com/trade-api/ws/v2) requires RSA-PSS signed headers from a US KYC account and returns 403 from non-US IPs, so it is measured from us-east only and excluded from the rank matrix. Limitless uses socket.io over HTTP long-polling, not standard WebSocket. Manifold, Myriad, PredictIt, Smarkets and Metaculus have no public WebSocket endpoint.

## Hyperliquid validator leaderboard: live net APR, uptime, commission

- Category: Blockchains
- Metric: Net yield (bps)
- Page: https://openchainbench.com/benchmarks/validator-yield-hyperliquid
- JSON: https://openchainbench.com/api/stat/validator-yield-hyperliquid
- Status: live
- Headline: infinitefield.xyz leads net yield at 2.24% (24h avg) on Hyperliquid validator leaderboard: live net APR, uptime, commission.

**Rankings (p50, 24h):**
1. infinitefield.xyz: 2.24% (p99 2.24%, success 100.0%, sample 1049500000)
2. HyperStake: 2.24% (p99 2.24%, success 100.0%, sample 574307000)
3. CMI: 2.24% (p99 2.24%, success 100.0%, sample 534172000)
4. Flowdex: 2.24% (p99 2.24%, success 100.0%, sample 250878000)
5. Hypurrscanning: 2.22% (p99 2.22%, success 100.0%, sample 1336990000)
6. Alphaticks: 2.22% (p99 2.22%, success 100.0%, sample 290323000)
7. Purrposeful x HyBridge x PiP: 2.20% (p99 2.20%, success 100.0%, sample 409981000)
8. Hyperliquid Strategies x Unit: 2.20% (p99 2.20%, success 100.0%, sample 1297890000)
9. Nansen x HypurrCollective: 2.20% (p99 2.20%, success 100.0%, sample 1253410000)
10. Hyperbeat x P2P x Hypio: 2.20% (p99 2.20%, success 100.0%, sample 222646000)
11. Hyper Foundation 3: 2.18% (p99 2.18%, success 100.0%, sample 3206480000)
12. Hyper Foundation 2: 2.18% (p99 2.18%, success 100.0%, sample 3100800000)
13. Hyper Foundation 1: 2.18% (p99 2.18%, success 100.0%, sample 3021910000)
14. Hyper Foundation 4: 2.18% (p99 2.18%, success 100.0%, sample 1980500000)
15. Hyper Foundation 5: 2.18% (p99 2.18%, success 100.0%, sample 876070000)
16. Hyperdash: 2.18% (p99 2.18%, success 100.0%, sample 557983000)
17. HypurrCorea - Spacebar x DeSpread: 2.18% (p99 2.18%, success 100.0%, sample 473458000)
18. USDT0 x Luganodes: 2.18% (p99 2.18%, success 100.0%, sample 488157000)
19. Bitwise Onchain Solutions x FalconX: 2.18% (p99 2.18%, success 100.0%, sample 258088000)
20. Liquid Spirit x Hydromancer x Rekt Gang: 2.18% (p99 2.18%, success 100.0%, sample 260722000)
21. Enigma - Hypedexer.com X Meria: 2.18% (p99 2.18%, success 100.0%, sample 192535000)
22. Kinetiq x Hyperion: 2.15% (p99 2.15%, success 100.0%, sample 399090000)
23. ValiDAO: 2.15% (p99 2.15%, success 100.0%, sample 376114000)
24. ASXN: 2.13% (p99 2.13%, success 100.0%, sample 502023000)
25. B-Harvest: 2.13% (p99 2.13%, success 100.0%, sample 297240000)
26. Anchorage By Figment: 2.02% (p99 2.02%, success 100.0%, sample 1712010000)

**Methodology**:
- Source: `POST api.hyperliquid.xyz/info {type: validatorSummaries}`. Fields used: `predictedApr` (day window), `stats[day].uptimeFraction`, `commission`, `stake` (in HYPE-wei, divide by 1e8), `isJailed`, `isActive`.
- Net yield formula: `net_yield_bps = predictedApr.day × uptimeFraction × 10000`. Jailed validators are forced to 0 regardless of published APR.
- Commission is a decimal fraction from the API (0.04 = 4%). Displayed in bps (0.04 × 10000 = 400 bps). Lower commission = better for delegators.
- Stake USD: `(stake / 1e8) × HYPE oracle price`. HYPE price from `metaAndAssetCtxs` `oraclePx` (fallback: markPx, midPx).
- Cadence: 5-minute scrape. HL validator stats move on sub-hour timescales (consensus window = day, but jail/unjail is near-instant), so 5-minute polling is sufficient.
- The bench includes all 34 validators currently returned by validatorSummaries, including jailed and near-zero-stake nodes, for complete transparency. Jailed nodes land at 0 bps yield.

## Most tradable markets on a perp DEX, live count across 14 venues

- Category: Trading
- Metric: Active markets (count)
- Page: https://openchainbench.com/benchmarks/perp-active-markets
- JSON: https://openchainbench.com/api/stat/perp-active-markets
- Status: live
- Headline: Aster leads active markets at 543 (24h) on Most tradable markets on a perp DEX, live count across 14 venues.

**Rankings (p50, 24h):**
1. Aster: 543 (p99 543, success 85.7%, sample 5760)
2. gains.trade: 366 (p99 366, success 66.7%, sample 5760)
3. edgeX: 292 (p99 292, success 54.5%, sample 5760)
4. Extended: 281 (p99 281, success 84.6%, sample 5760)
5. Aevo: 217 (p99 217, success 71.4%, sample 5760)
6. Lighter: 210 (p99 210, success 85.7%, sample 5760)
7. Hyperliquid: 177 (p99 177, success 85.6%, sample 5760)
8. GRVT: 173 (p99 173, success 71.4%, sample 5760)
9. dYdX v4: 99 (p99 99, success 85.7%, sample 5760)
10. Ostium: 75 (p99 75, success 66.7%, sample 5760)
11. Pacifica: 75 (p99 75, success 71.4%, sample 5760)
12. Vertex: 64 (p99 64, success 85.7%, sample 5760)
13. Paradex: 61 (p99 61, success 85.7%, sample 5760)
14. Polymarket: 39 (p99 39, success 80.0%, sample 5760)

**Methodology**:
- Cadence: every 5 minutes per venue in parallel, 10 second timeout per request.
- Hyperliquid: info metaAndAssetCtxs, count of non-delisted assets. Active perp markets only, crypto assets.
- Lighter: orderBookDetails, count of markets where market_type==perp and status==active. Native API, mainnet only.
- dYdX v4: indexer perpetualMarkets, count of non-deactivated markets.
- Paradex: markets summary endpoint on Starknet L2, count of active perp markets.
- edgeX: native markets endpoint, count of active perp markets on zkSync.
- Aster: fapi exchangeInfo, count of instruments with contractType==PERPETUAL and status==TRADING on BNB Chain.
- Vertex: public indexer, count of active perp products on Arbitrum.
- GRVT: public markets endpoint, count of active instruments on ZK Stack.
- Extended: public markets API, count of active perp markets on StarkEx.
- Aevo: public markets endpoint, count of active perp instruments on OP Stack.
- Pacifica: onchain reads on the Solana program state, count of active perp markets.
- Ostium: Arbitrum subgraph, count of active pairs. Covers FX and commodities alongside crypto.
- Polymarket: public perps tickers endpoint on Polygon, count of listed instruments.
- gains.trade: Mobula perp pairs catalog (GET /api/2/perp/pairs, dex=gains, mainnet only). Covers crypto, forex, stocks, indices and commodities across Arbitrum, Base, Polygon and ApeChain.
- Headline: avg_over_time of the live market count gauge over the last 24 hours. Listings change infrequently so the 24h average is effectively the current count.
- Failures: a venue that errors keeps its last gauge value and its perp_venue_health gauge drops toward 0; the leaderboard tags it as stale.

## Perp DEX cost invariance: all-in bps at $1M vs $1k, live slope ranked

- Category: Trading
- Metric: Cost slope ($1M / $1k) (x)
- Page: https://openchainbench.com/benchmarks/perp-cost-slope
- JSON: https://openchainbench.com/api/stat/perp-cost-slope
- Status: live
- Headline: gains.trade leads cost slope ($1m / $1k) at 1.000x (p50, 24h) on Perp DEX cost invariance: all-in bps at $1M vs $1k, live slope ranked.

**Rankings (p50, 24h):**
1. gains.trade: 1.000x (p99 1.000x, success 100.0%, sample 5755)
2. GMX v2: 1.000x (p99 1.000x, success 99.7%, sample 5755)
3. Hyperliquid: 1.094x (p99 1.004x, success 100.0%, sample 5755)
4. Aster: 1.094x (p99 1.003x, success 100.0%, sample 5755)
5. Extended: 1.243x (p99 1.004x, success 99.7%, sample 5755)
6. edgeX: 1.290x (p99 1.002x, success 100.0%, sample 5755)
7. dYdX v4: 2.08x (p99 1.114x, success 100.0%, sample 5755)
8. Lighter: 5.13x (p99 1.173x, success 100.0%, sample 5635)

**Methodology**:
- Cadence: derived in PromQL from perp_fees_all_in_bps_tier, refreshed every 5 minutes by the perp-fees harness (bench 007).
- Cost slope = avg_over_time(all_in_bps_tier{notional=1000000}[24h]) / ignoring(notional) avg_over_time(all_in_bps_tier{notional=1000}[24h]) per venue per asset. A ratio of 1.00 means flat cost across sizes.
- Oracle-priced venues (gains.trade, GMX v2): the fee is a flat percentage of position size with no orderbook. The $1M all-in equals the $1k all-in in bps exactly, so slope = 1.00 always.
- Orderbook venues (Hyperliquid, dYdX, Lighter, Extended, Aster, edgeX): the $1M tier walks deeper into the book than the $1k tier, so the spread component grows and slope > 1.00.
- Missing $1M tier: when the visible book cannot absorb $1M the harness skips the tier and increments perp_fees_tier_skipped_total rather than extrapolating. The slope PromQL returns no data for that venue, shown as N/A in the leaderboard.
- Fill-rate panel: count_over_time(tier{notional=1000000}[24h]) / ignoring(notional) count_over_time(tier{notional=1000}[24h]) per venue per asset. 1.00 = tier always filled; 0.50 = tier filled half the time; 0.00 = tier never filled.
- Chain tabs: the board is scoped per asset (ETH, BTC, SOL) because book depth differs significantly across assets and cross-asset averaging obscures the signal.
- Failures and stale data: inherited from the perp-fees harness. A venue that errors keeps its last gauge and its health drops to 0.

## Perp DEX mark price fidelity: deviation from CEX spot reference, live

- Category: Trading
- Metric: Mark price deviation (bps)
- Page: https://openchainbench.com/benchmarks/perp-mark-price-lag
- JSON: https://openchainbench.com/api/stat/perp-mark-price-lag
- Status: live
- Headline: Hyperliquid leads mark price deviation at 0.041% (24h avg) on Perp DEX mark price fidelity: deviation from CEX spot reference, live.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.041% (p99 0.057%, success 99.9%, sample 5760)
2. Lighter: 0.053% (p99 0.070%, success 100.0%, sample 5760)
3. Paradex: 0.090% (p99 0.11%, success 100.0%, sample 5760)
4. dYdX v4: 0.098% (p99 0.15%, success 100.0%, sample 5760)
5. gains.trade: 0.11% (p99 0.12%, success 100.0%, sample 5760)
6. GMX v2: 0.11% (p99 0.12%, success 100.0%, sample 5760)

**Methodology**:
- Cadence: every 60 seconds in parallel across all venues. Reference price and venue mark prices are fetched in the same cycle, so the comparison is time-aligned.
- Reference price: Binance REST /api/v3/ticker/bookTicker for the selected asset (ETHUSDT, BTCUSDT, SOLUSDT). The harness uses the mid of best bid and best ask as the reference.
- gains.trade (Gains v8, oracle-priced): Pyth hermes API /v2/updates/price/latest for the ETH/USD, BTC/USD, SOL/USD feed IDs. Pyth is the primary real-time oracle Gains v8 weights in its mark price computation. Deviation from Binance spot is structurally near zero.
- GMX v2 (oracle-priced): same Pyth hermes API endpoint. GMX v2 uses Chainlink as primary oracle; Pyth prices are an accepted proxy since both track CEX spot within 1 bps in normal conditions. Conservative labelling: formula tooltip notes the Pyth proxy.
- Hyperliquid: POST /info {type:metaAndAssetCtxs} returns markPx per asset. This is the venue's own mark price used for P&L and liquidations, derived from their HyperBFT oracle.
- dYdX v4: GET /v4/perpetualMarkets from the dYdX indexer returns indexPrice per market. indexPrice is the oracle-anchored price dYdX uses for margin and liquidation calculations.
- Lighter: orderbook mid computed from GET /api/v1/orderBookOrders best bid and ask. Lighter does not publish a separate mark price endpoint; the orderbook mid is the closest available approximation.
- Paradex: GET /markets endpoint returns markPrice per instrument on Starknet L2.
- Deviation formula: abs(mark - reference) / reference x 10000, in basis points. Signed version (mark - reference) / reference x 10000 also published.
- Failure handling: a venue that errors or times out leaves the previous gauge in place and increments perp_mark_fetch_errors_total. The health gauge drops to 0, flagging the row as stale in the UI.
- Scope: this bench measures the persistent deviation visible at 60-second polling. Sub-second wick events that resolve within a single poll interval are not captured. The methodology page names this explicitly to avoid overstating what is measured.

## Perp DEX security track record: days without a recorded exploit, live

- Category: Trading
- Metric: Days since last exploit (count)
- Page: https://openchainbench.com/benchmarks/perp-protocol-longevity
- JSON: https://openchainbench.com/api/stat/perp-protocol-longevity
- Status: live
- Headline: gains.trade leads days since last exploit at 1,719 (24h) on Perp DEX security track record: days without a recorded exploit, live.

**Rankings (p50, 24h):**
1. gains.trade: 1,719 (p99 1,719, success 100.0%, sample 5760)
2. Lighter: 1,142 (p99 1,142, success 100.0%, sample 5760)
3. dYdX v4: 1,050 (p99 1,050, success 100.0%, sample 5760)
4. Paradex: 1,050 (p99 1,050, success 100.0%, sample 5760)
5. Hyperliquid: 1,019 (p99 1,019, success 100.0%, sample 5760)
6. GMX v2: 403 (p99 403, success 100.0%, sample 5760)

**Methodology**:
- Registry: a versioned YAML file embedded in the harness binary at build time. Fields per incident: venue_slug, date (YYYY-MM-DD), amount_usd, type (exploit, oracle-manipulation, admin-key, bridge), source_url.
- Counter formula: (Unix timestamp at query time - Unix timestamp of max(launch_date, last_incident_date)) / 86400. Emitted as perp_protocol_days_clean{venue}.
- Incident criteria: direct theft or permanent loss of user funds via a documented smart contract vulnerability or privileged key compromise. Oracle manipulation without contract exploit is excluded. Market-structure events (liquidation cascades, large-position forced close) are excluded.
- gains.trade: launched 2021-12-01. No incidents in tracked sources as of registry date 2026-08-02. Clean streak = days since 2021-12-01.
- GMX v2: launched 2023-08-01. Incident 2025-07-09: reentrancy in vault and order-flow logic, estimated loss USD 42 000 000, source coinperps.xyz post-mortem. Clean streak = days since 2025-07-09.
- Hyperliquid: launched 2023-11-01. No protocol exploit in tracked sources. Note: the March 2025 JellyJelly forced close was a market-structure event, not a smart contract exploit, and is excluded per criteria. DeFiLlama enrichment filters entries with no confirmed financial loss (amount null or 0) to avoid false positives such as unrelated projects that share a name substring.
- dYdX v4: launched on the Cosmos appchain 2023-10-01. No protocol exploit on v4. dYdX v1 and v2 on Ethereum had oracle manipulation events that are excluded here (different contract, different era).
- Lighter: launched 2023-07-01. No incidents in tracked sources.
- Paradex: launched 2023-10-01. No incidents in tracked sources.
- Registry update process: a nightly job polls rekt.news for new entries matching venue slugs and raises a review alert. A maintainer confirms and commits the updated registry.yaml. The harness auto-rebuilds and the counter updates on the next deploy cycle.
- Survivorship note: older protocols have had more calendar time in which an exploit could occur. A long streak is a positive signal but is partly explained by age. The perp_protocol_incidents_total counter lets readers weight the streak against the full history.

## Fastest free Kava RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 10 ms (p99 373 ms, success 100.0%, sample 4310.71)
2. PublicNode: 88 ms (p99 604 ms, success 100.0%, sample 4309.71)
3. Kava Labs: 232 ms (p99 944 ms, success 100.0%, sample 4324.71)
4. dRPC: 242 ms (p99 394 ms, success 93.2%, sample 4296.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="kava"`. Provider coverage: 5 no-key endpoints.

## Fastest free Zora RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Zora Network: 176 ms (p99 214 ms, success 100.0%, sample 4321.71)
2. Conduit: 180 ms (p99 211 ms, success 100.0%, sample 4321.71)
3. dRPC: 311 ms (p99 553 ms, success 91.4%, sample 4317.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="zora"`. Provider coverage: 4 no-key endpoints.

## Perp DEX asset breadth: non-crypto markets live, forex + stocks + indices + commodities

- Category: Trading
- Metric: Non-crypto markets (count)
- Page: https://openchainbench.com/benchmarks/perp-asset-breadth
- JSON: https://openchainbench.com/api/stat/perp-asset-breadth
- Status: live
- Headline: gains.trade leads non-crypto markets at 110 (24h) on Perp DEX asset breadth: non-crypto markets live, forex + stocks + indices + commodities.

**Rankings (p50, 24h):**
1. gains.trade: 110 (p99 110, success 100.0%, sample n/a)
2. Lighter: 40 (p99 40, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 5 minutes. Source: Mobula /api/2/perp/pairs for gains.trade and Lighter; native venue APIs for others.
- gains.trade: Mobula catalog bucketed by assetClass. Counted classes: forex (EUR/USD, GBP/JPY...), stocks (AAPL, TSLA, NVDA, AMZN...), indices (SPX, NDX, DJI...), commodities (XAU, XAG, WTI, NATGAS...). Mainnet only (arbitrum-sepolia excluded).
- Lighter: same Mobula catalog. Lighter lists non-crypto markets but with smaller catalogs per class.
- Hyperliquid: native info metaAndAssetCtxs endpoint verified crypto-only. Non-crypto count: 0.
- GMX v2: DataStore onchain pairs verified crypto-only (BTC, ETH, ARB, SOL, AVAX, LINK, DOGE, UNI). Non-crypto count: 0.
- dYdX v4: indexer perpetualMarkets verified crypto-only. Non-crypto count: 0.
- Ostium: Arbitrum subgraph verified: FX pairs (EUR/USD, GBP/USD, XAU/USD) present but counted separately from this bench which focuses on the EVM DEX cohort. Count represents the Mobula catalog only.
- Asset class taxonomy: Mobula editorial, updated at listing time. The bench re-reads on every 5-minute tick so new listings appear automatically.

## Fastest free Abstract RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Abstract Foundation: 328 ms (p99 1.29 s, success 100.0%, sample 4313.71)
2. dRPC: 343 ms (p99 1.22 s, success 90.3%, sample 4308.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="abstract"`. Provider coverage at launch: 3 no-key endpoints.

## Fastest free ApeChain RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. ApeChain: 190 ms (p99 281 ms, success 100.0%, sample 4309.71)
2. dRPC: 215 ms (p99 522 ms, success 92.3%, sample 4310.71)
3. Tenderly: 332 ms (p99 473 ms, success 100.0%, sample 4310.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="apechain"`. Provider coverage: 4 no-key endpoints.

## Fastest free Lisk RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 15 ms (p99 110 ms, success 98.2%, sample 4317.71)
2. Lisk: 330 ms (p99 1.34 s, success 100.0%, sample 4310.71)
3. Tenderly: 333 ms (p99 382 ms, success 100.0%, sample 4315.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="lisk"`. Provider coverage: 4 no-key endpoints.

## Fastest free Swellchain RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 6 ms (p99 37 ms, success 100.0%, sample 4303.71)
2. dRPC: 173 ms (p99 622 ms, success 92.1%, sample 4302.71)
3. Sentio: 189 ms (p99 280 ms, success 100.0%, sample 4311.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="swellchain"`. Provider coverage: 4 no-key endpoints.

## Fastest free Cyber RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Cyber Network: 173 ms (p99 211 ms, success 100.0%, sample 4324.71)
2. AltLayer: 178 ms (p99 226 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="cyber"`. Provider coverage at launch: 3 no-key endpoints.

## Fastest free Rootstock RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Rootstock Foundation: 190 ms (p99 818 ms, success 99.9%, sample 4323.72)
2. dRPC: 288 ms (p99 1.54 s, success 64.1%, sample 4310.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="rootstock"`. Provider coverage: 3 no-key endpoints.

## Fastest free Metis RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. PublicNode: 95 ms (p99 621 ms, success 100.0%, sample 4324.71)
2. dRPC: 234 ms (p99 302 ms, success 92.8%, sample 4299.71)
3. Metis: 244 ms (p99 868 ms, success 100.0%, sample 4308.71)
4. Thirdweb: 621 ms (p99 663 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="metis"`. Provider coverage: 4 no-key endpoints.

## Fastest free Manta Pacific RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Manta Network: 182 ms (p99 217 ms, success 100.0%, sample 4305.71)
2. dRPC: 198 ms (p99 1.38 s, success 90.2%, sample 4323.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="manta"`. Provider coverage: 4 no-key endpoints.

## Fastest free Story RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 71 ms (p99 251 ms, success 100.0%, sample 4324.71)
2. Story Foundation: 79 ms (p99 113 ms, success 100.0%, sample 4309.71)
3. Stakely: 271 ms (p99 1.06 s, success 99.0%, sample 4300.71)
4. PublicNode: 463 ms (p99 735 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="story"`. Provider coverage: 4 no-key endpoints.

## Fastest free Morph RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Morph: 90 ms (p99 174 ms, success 100.0%, sample 4310.71)
2. QuickNode: 175 ms (p99 199 ms, success 100.0%, sample 4323.71)
3. dRPC: 257 ms (p99 316 ms, success 92.5%, sample 4304.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="morph"`. Provider coverage: 4 no-key endpoints.

## Fastest free Moonriver RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. OnFinality: 62 ms (p99 1.99 s, success 100.0%, sample 4304.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="moonriver"`. Provider coverage: 3 no-key endpoints. UnitedBloc removed (DNS dead).

## Fastest free Hemi RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 165 ms (p99 644 ms, success 92.7%, sample 4300.71)
2. Hemi Labs: 178 ms (p99 376 ms, success 99.8%, sample 4320.72)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="hemi"`. Provider coverage: 3 no-key endpoints.

## Fastest free BOB RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. BOB: 181 ms (p99 209 ms, success 100.0%, sample 4302.71)
2. dRPC: 218 ms (p99 754 ms, success 92.5%, sample 4305.71)
3. Tenderly: 331 ms (p99 380 ms, success 100.0%, sample 4315.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="bob"`. Provider coverage: 4 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. Polygon zkEVM: 308 ms (p99 421 ms, success 100.0%, sample 4316.71)
2. dRPC: 326 ms (p99 427 ms, success 92.7%, sample 4298.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="polygon-zkevm"`. Provider coverage: 3 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. PublicNode: 92 ms (p99 620 ms, success 100.0%, sample 4318.71)
2. dRPC: 234 ms (p99 599 ms, success 92.6%, sample 4312.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="arbitrum-nova"`. Provider coverage: 3 no-key endpoints.

## Fastest free X Layer RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. X Layer: 45 ms (p99 464 ms, success 100.0%, sample 4314.71)
2. dRPC: 384 ms (p99 751 ms, success 92.5%, sample 4319.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="xlayer"`. Provider coverage: 3 no-key endpoints.

## Fastest free Flare RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 131 ms (p99 372 ms, success 100.0%, sample 4316.71)
2. dRPC: 236 ms (p99 300 ms, success 91.6%, sample 4322.71)
3. Flare Foundation: 312 ms (p99 1.26 s, success 99.8%, sample 4303.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="flare"`. Provider coverage: 4 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. Ankr: 6 ms (p99 45 ms, success 100.0%, sample 4310.71)
2. dRPC: 168 ms (p99 595 ms, success 91.8%, sample 4308.71)
3. Core DAO: 245 ms (p99 293 ms, success 100.0%, sample 4322.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="core"`. Provider coverage: 4 no-key endpoints.

## Fastest free Fuse Network RPC, live no-key EVM endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 192 ms (p99 418 ms, success 93.4%, sample 4297.71)
2. Fuse Foundation: 228 ms (p99 271 ms, success 100.0%, sample 4314.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- 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 with a parsable hex block number), `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.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="fuse"`. Provider coverage: 3 no-key endpoints.

## Perp DEX capital efficiency: active markets per $M TVL, live

- Category: Trading
- Metric: Markets per $M TVL (count)
- Page: https://openchainbench.com/benchmarks/perp-capital-efficiency
- JSON: https://openchainbench.com/api/stat/perp-capital-efficiency
- Status: live
- Headline: gains.trade leads markets per $m tvl at 36 (24h) on Perp DEX capital efficiency: active markets per $M TVL, live.

**Rankings (p50, 24h):**
1. gains.trade: 36 (p99 36, success 66.7%, sample 5760)
2. Ostium: 4 (p99 4, success 66.7%, sample 5760)
3. dYdX v4: 0.870 (p99 0.870, success 85.7%, sample 5760)
4. Hyperliquid: 0.029 (p99 0.029, success 85.6%, sample 5760)

**Methodology**:
- Cadence: every 5 minutes. Both active_markets and TVL are re-read on the same sweep cycle.
- Active markets: native venue API per the perp-active-markets bench methodology. gains.trade: Mobula perp pairs catalog (mainnet only). Hyperliquid: info metaAndAssetCtxs. dYdX: indexer perpetualMarkets. Others: native endpoints.
- TVL: DefiLlama /protocol/{slug} currentChainTvls. Staking and pool2 keys excluded. Multi-chain TVL summed across all deployment chains.
- gains.trade TVL: GToken vault across Arbitrum, Base, Polygon and ApeChain. This is the shared liquidity pool that backs all synthetic pairs simultaneously.
- Hyperliquid TVL: total user deposits (USDC). Funds serve as both margin and implicit market-maker collateral; every listed pair draws from this pool for maker fills.
- Ratio formula: avg_over_time(markets[24h]) / avg_over_time(tvl_usd[24h]) * 1_000_000.
- Interpretation: a ratio of 40 means the venue can sustain 40 active markets per $1M locked. Higher is more capital-efficient in terms of market breadth.

## Fastest free Filecoin RPC, live no-key FEVM endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 6 ms (p99 43 ms, success 100.0%, sample 4323.71)
2. Glif: 247 ms (p99 736 ms, success 100.0%, sample 4324.71)
3. dRPC: 293 ms (p99 571 ms, success 92.1%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="filecoin"`. Provider coverage at launch: 3 no-key endpoints (Glif, dRPC, Ankr).

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

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

**Rankings (p50, 24h):**
1. Canto Official: 183 ms (p99 542 ms, success 100.0%, sample 4313.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="canto"`. Provider coverage: 1 no-key endpoint (Canto Official). dRPC requires an API key; Ankr and PublicNode dropped free Canto support.

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

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

**Rankings (p50, 24h):**
1. Aurora Labs: 192 ms (p99 505 ms, success 100.0%, sample 4310.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="aurora"`. Provider coverage: 1 no-key endpoint (Aurora Official). Ankr and dRPC require an API key for Aurora and have been removed.

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

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

**Rankings (p50, 24h):**
1. Ankr: 5 ms (p99 37 ms, success 100.0%, sample 4324.71)
2. Bitlayer Official: 13 ms (p99 33 ms, success 99.7%, sample 4320.77)
3. dRPC: 231 ms (p99 458 ms, success 91.8%, sample 4319.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="bitlayer"`. Provider coverage at launch: 3 no-key endpoints (Bitlayer Official, dRPC, Ankr).

## Fastest free B² Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 345 ms (p99 780 ms, success 92.8%, sample 4314.71)
2. B² Network Official: 492 ms (p99 608 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="b2"`. Provider coverage at launch: 3 no-key endpoints (B² Official, dRPC, Thirdweb).

## Fastest free dYdX Chain RPC, live no-key Cosmos SDK endpoint latency

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

**Rankings (p50, 24h):**
1. PublicNode: 101 ms (p99 623 ms, success 100.0%, sample 4309.71)
2. Polkachu: 179 ms (p99 350 ms, success 100.0%, sample 4324.71)
3. LavenderFive: 198 ms (p99 528 ms, success 100.0%, sample 4308.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip at ~1 s/block), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="dydx"`. Provider coverage at launch: 3 no-key endpoints (PublicNode, Polkachu, LavenderFive).

## Fastest free Celestia RPC, live no-key Cosmos SDK endpoint latency

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

**Rankings (p50, 24h):**
1. Polkachu: 193 ms (p99 381 ms, success 99.7%, sample 4308.71)
2. LavenderFive: 197 ms (p99 424 ms, success 100.0%, sample 4314.71)
3. PublicNode: 464 ms (p99 723 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="celestia"`. Provider coverage at launch: 3 no-key endpoints (PublicNode, Polkachu, LavenderFive).

## Fastest free Boba Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Boba Foundation: 252 ms (p99 783 ms, success 100.0%, sample 4305.71)
2. dRPC: 287 ms (p99 488 ms, success 91.6%, sample 4312.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="boba"`. Provider coverage: 2 no-key endpoints (Boba Foundation, dRPC).

## Fastest free XDC Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 7 ms (p99 46 ms, success 100.0%, sample 4323.71)
2. XDC eRPC: 127 ms (p99 328 ms, success 99.9%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="xdc"`. Provider coverage: 2 no-key endpoints (Ankr, XDC eRPC). XDC Foundation official, XDCrpc and XDC.org stopped responding to probes and have been removed.

## Fastest free Astar Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. OnFinality: 61 ms (p99 2.01 s, success 100.0%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="astar"`. Provider coverage: 2 no-key endpoints (OnFinality, 1RPC). PublicNode returned 404; BlastAPI DNS is dead.

## Fastest free Oasis Sapphire RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Oasis Foundation: 182 ms (p99 275 ms, success 100.0%, sample 4321.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="oasis-sapphire"`. Provider coverage at launch: 1 no-key endpoint (Oasis Foundation).

## Fastest free Oasis Emerald RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Oasis Foundation: 244 ms (p99 769 ms, success 100.0%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="oasis-emerald"`. Provider coverage at launch: 1 no-key endpoint (Oasis Foundation).

## Fastest free Conflux eSpace RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Conflux Foundation: 145 ms (p99 368 ms, success 99.9%, sample 4312.71)
2. Conflux Global: 252 ms (p99 825 ms, success 100.0%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="conflux"`. Provider coverage at launch: 3 no-key endpoints (Conflux Foundation, Conflux Global, Unifra).

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

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

**Rankings (p50, 24h):**
1. IoTeX Mirror: 182 ms (p99 1.84 s, success 99.8%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="iotex"`. Provider coverage at launch: 3 no-key endpoints (IoTeX Mirror, Ankr, Thirdweb).

## Fastest free Harmony ONE RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Harmony S0: 170 ms (p99 170 ms, success 0.0%, sample 4321.97)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="harmony"`. Provider coverage at launch: 1 no-key endpoint (Harmony S0).

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

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

**Rankings (p50, 24h):**
1. Zircuit Foundation: 179 ms (p99 253 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="zircuit"`. Provider coverage: 1 no-key endpoint (Zircuit Foundation).

## Fastest free Plume Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 302 ms (p99 481 ms, success 90.4%, sample 4311.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="plume"`. Provider coverage at launch: 2 no-key endpoints (Plume Foundation, dRPC).

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

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

**Rankings (p50, 24h):**
1. Vana Foundation: 175 ms (p99 197 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="vana"`. Provider coverage at launch: 1 no-key endpoint (Vana Foundation).

## Fastest free Gravity Alpha RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Ankr: 5 ms (p99 37 ms, success 100.0%, sample 4310.71)
2. Gravity Foundation: 178 ms (p99 212 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="gravity"`. Provider coverage at launch: 2 no-key endpoints (Gravity Foundation, Ankr).

## Fastest free Reya Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Reya Foundation: 349 ms (p99 378 ms, success 100.0%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="reya"`. Provider coverage at launch: 2 no-key endpoints (Reya Foundation, Thirdweb).

## Fastest free Akash Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Polkachu: 193 ms (p99 373 ms, success 99.7%, sample 4308.71)
2. Ecostake: 233 ms (p99 3.78 s, success 99.9%, sample 4303.71)
3. PublicNode: 411 ms (p99 678 ms, success 100.0%, sample 4312.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="akash"`. Provider coverage at launch: 4 no-key endpoints (PublicNode, Polkachu, Ecostake, AutoStake).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 194 ms (p99 373 ms, success 100.0%, sample 4307.71)
2. LavenderFive: 199 ms (p99 543 ms, success 99.6%, sample 4318.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="stride"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, LavenderFive).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 192 ms (p99 377 ms, success 99.7%, sample 4302.71)
2. PublicNode: 201 ms (p99 634 ms, success 100.0%, sample 4316.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="juno"`. Provider coverage at launch: 4 no-key endpoints (Polkachu, PublicNode, LavenderFive, AutoStake).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 193 ms (p99 366 ms, success 100.0%, sample 4303.71)
2. LavenderFive: 197 ms (p99 485 ms, success 100.0%, sample 4310.71)
3. PublicNode: 259 ms (p99 710 ms, success 100.0%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="axelar"`. Provider coverage at launch: 4 no-key endpoints (Polkachu, PublicNode, LavenderFive, AutoStake).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 192 ms (p99 371 ms, success 100.0%, sample 4322.71)
2. LavenderFive: 198 ms (p99 485 ms, success 100.0%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="dymension"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, LavenderFive).

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

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

**Rankings (p50, 24h):**
1. Persistence Foundation: 172 ms (p99 510 ms, success 100.0%, sample 4310.71)
2. Polkachu: 192 ms (p99 368 ms, success 100.0%, sample 4304.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="persistence"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, Persistence Foundation).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 191 ms (p99 373 ms, success 100.0%, sample 4323.71)
2. PublicNode: 252 ms (p99 638 ms, success 100.0%, sample 4314.71)
3. Coreum Foundation: 644 ms (p99 806 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="coreum"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, Coreum Foundation).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 192 ms (p99 369 ms, success 100.0%, sample 4303.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="nolus"`. Provider coverage at launch: 2 no-key endpoints (Polkachu, AutoStake).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 193 ms (p99 375 ms, success 100.0%, sample 4321.71)
2. LavenderFive: 197 ms (p99 379 ms, success 100.0%, sample 4318.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="archway"`. Provider coverage at launch: 4 no-key endpoints (Polkachu, LavenderFive, Archway Foundation, PublicNode).

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

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

**Rankings (p50, 24h):**
1. Nibiru Foundation: 175 ms (p99 526 ms, success 99.9%, sample 4309.72)
2. Polkachu: 192 ms (p99 373 ms, success 99.7%, sample 4323.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="nibiru"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, Nibiru Foundation).

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

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

**Rankings (p50, 24h):**
1. Polkachu: 191 ms (p99 329 ms, success 99.7%, sample 4313.71)
2. Quicksilver Foundation: 276 ms (p99 324 ms, success 100.0%, sample 4314.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="quicksilver"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, Quicksilver Foundation).

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

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

**Rankings (p50, 24h):**
1. LavenderFive: 180 ms (p99 408 ms, success 100.0%, sample 4322.71)
2. Polkachu: 193 ms (p99 374 ms, success 100.0%, sample 4323.71)
3. PublicNode: 418 ms (p99 763 ms, success 100.0%, sample 4316.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="terra"`. Provider coverage at launch: 4 no-key endpoints (Polkachu, PublicNode, LavenderFive, AutoStake).

## Fastest free Regen Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Polkachu: 192 ms (p99 378 ms, success 100.0%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="regen"`. Provider coverage at launch: 2 no-key endpoints (Polkachu, PublicNode).

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

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

**Rankings (p50, 24h):**
1. STAVR: 239 ms (p99 723 ms, success 100.0%, sample 4310.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"status","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 to 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 with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="comdex"`. Provider coverage: 1 no-key endpoint (STAVR).

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

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

**Rankings (p50, 24h):**
1. Fantom Foundation: 236 ms (p99 269 ms, success 100.0%, sample 4310.71)
2. dRPC: 256 ms (p99 317 ms, success 92.2%, sample 4306.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="fantom"`. Provider coverage at launch: 5 no-key endpoints (Fantom Foundation, dRPC, Ankr, Thirdweb, Blast API).

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

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

**Rankings (p50, 24h):**
1. OnFinality: 57 ms (p99 2.25 s, success 100.0%, sample 4312.71)
2. PublicNode: 286 ms (p99 706 ms, success 100.0%, sample 4316.71)
3. dRPC: 740 ms (p99 1.04 s, success 91.6%, sample 4321.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"chain_getHeader","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 to 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + parsable hex block number), `http_err`, `jsonrpc_err`, `stale` (more than 40 relay blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="kusama"`. Provider coverage at launch: 6 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. Thirdweb: 679 ms (p99 723 ms, success 0.5%, sample 4309.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="zetachain"`. Provider coverage: 1 no-key endpoint (Thirdweb). BlockPI returned 404; AllThatNode DNS is dead.

## Fastest free HAQQ Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. PublicNode: 87 ms (p99 628 ms, success 100.0%, sample 4321.71)
2. HAQQ Foundation: 196 ms (p99 634 ms, success 100.0%, sample 4309.71)
3. dRPC: 237 ms (p99 596 ms, success 89.3%, sample 4300.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="haqq"`. Provider coverage at launch: 4 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. Etherlink Foundation: 6 ms (p99 50 ms, success 100.0%, sample 4310.71)
2. dRPC: 213 ms (p99 460 ms, success 91.9%, sample 4313.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="etherlink"`. Provider coverage at launch: 4 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. PublicNode: 90 ms (p99 392 ms, success 100.0%, sample 4314.71)
2. Chiliz Foundation: 166 ms (p99 505 ms, success 99.7%, sample 4300.71)
3. Ankr: 179 ms (p99 394 ms, success 100.0%, sample 4324.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="chiliz"`. Provider coverage at launch: 4 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. dRPC: 169 ms (p99 651 ms, success 91.8%, sample 4319.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="wemix"`. Provider coverage at launch: 4 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. Flare Foundation: 312 ms (p99 1.26 s, success 99.7%, sample 4322.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="songbird"`. Provider coverage: 1 no-key endpoint (Flare Foundation official). FTSO AU removed after DNS went dead.

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

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

**Rankings (p50, 24h):**
1. Cronos (Crypto.com): 244 ms (p99 282 ms, success 100.0%, sample 4314.71)
2. dRPC: 272 ms (p99 780 ms, success 91.1%, sample 4299.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="cronos-zkevm"`. Provider coverage at launch: 3 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. dRPC: 245 ms (p99 373 ms, success 92.5%, sample 4298.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="ethereum-classic"`. Provider coverage: 1 no-key endpoint (dRPC). ETCDesktop and ETCMC stopped responding to probes and have been removed.

## Fastest free Telos EVM RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. dRPC: 196 ms (p99 409 ms, success 92.6%, sample 4305.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="telos"`. Provider coverage: 1 no-key endpoint (dRPC). Telos Foundation official returned 404 and has been removed.

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

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

**Rankings (p50, 24h):**
1. PublicNode: 82 ms (p99 341 ms, success 100.0%, sample 4314.71)
2. G4MM4: 185 ms (p99 607 ms, success 99.8%, sample 4302.72)
3. PulseChain Foundation: 245 ms (p99 624 ms, success 100.0%, sample 4315.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="pulsechain"`. Provider coverage at launch: 3 no-key endpoints.

## Fastest free Warden Protocol RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. Warden Foundation: 184 ms (p99 282 ms, success 99.8%, sample 4312.71)
2. PublicNode: 418 ms (p99 764 ms, success 100.0%, sample 4307.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. 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 to 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`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="warden"`. Provider coverage at launch: 2 no-key endpoints.

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

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

**Rankings (p50, 24h):**
1. Orai Foundation: 197 ms (p99 374 ms, success 100.0%, sample 4312.71)
2. PublicNode: 305 ms (p99 739 ms, success 100.0%, sample 4316.71)

**Methodology**:
- Cadence: every 60 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: Tendermint/CometBFT `status` JSON-RPC call. 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 to 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + parsable latest_block_height), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="oraichain"`. Provider coverage at launch: 3 no-key endpoints.

## Fastest free Peaq Network RPC, live no-key endpoint latency

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

**Rankings (p50, 24h):**
1. OnFinality: 56 ms (p99 1.97 s, success 100.0%, sample 4309.71)
2. PublicNode: 240 ms (p99 352 ms, success 100.0%, sample 4303.71)

**Methodology**:
- Cadence: every 60 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":<rotating>,"method":"chain_getHeader","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 to 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours.
- Call-result classification: `ok` (HTTP 200 + parsable hex block number), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`.
- 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, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to `chain="peaq"`. Provider coverage at launch: 3 no-key endpoints.

## Solana meme launchpad leaderboard: PumpFun vs Flap vs Bankr, live 24h volume

- Category: Trading
- Metric: 24h volume (usd)
- Page: https://openchainbench.com/benchmarks/solana-launchpad-wars
- JSON: https://openchainbench.com/api/stat/solana-launchpad-wars
- Status: live
- Headline: PumpFun leads 24h volume at $100.05M (24h) on Solana meme launchpad leaderboard: PumpFun vs Flap vs Bankr, live 24h volume.

**Rankings (p50, 24h):**
1. PumpFun: $100.05M (p99 $100.05M, success 100.0%, sample 3352560)
2. Flap: $25.58M (p99 $25.58M, success 100.0%, sample 456907)
3. Meteora DBC: $8.81M (p99 $8.81M, success 100.0%, sample 755113)
4. NOXA Fun: $6.00M (p99 $6.00M, success 100.0%, sample 30236)
5. LetsCash: $1.64M (p99 $1.64M, success 100.0%, sample 26734)
6. Bankr: $1.50M (p99 $1.50M, success 100.0%, sample 20434)
7. dontblink: $263.7K (p99 $263.7K, success 100.0%, sample 1530)
8. Raydium Launchlab: $64.8K (p99 $64.8K, success 100.0%, sample 1557)

**Methodology**:
- Source: Mobula lighthouse (api.mobula.io/api/2/market/lighthouse), byLaunchpad field. Mobula indexes all Solana bonding-curve programs and aggregates swap events into 24h rolling windows updated approximately every minute on Mobula's side.
- Poll cadence: harness fetches the endpoint every 15 minutes and updates Prometheus gauges. Prometheus scrapes :2112/metrics every 60 seconds.
- Volume: sum of all swap event notional values (in USD at time of swap) within the last 24 hours for swaps routed through this launchpad's program. Higher = more active market.
- Fees: on-chain protocol fees collected by the launchpad program within the last 24 hours. Off-chain relay fees and referral fees are not included.
- Trades: count of individual swap events within the last 24 hours.
- Launchpad scope: this bench covers bonding-curve launchpads (PumpFun, Flap, Bankr, LetsCash, NOXA Fun, Meteora DBC, Raydium Launchlab). Trading frontends that route through multiple launchpads (GMGN, Axiom, Fomo, Trojan) are a separate bench.
- PumpFun note: PumpFun volume here is bonding-curve activity only. Tokens that graduate from the bonding curve to PumpSwap AMM are counted separately under PumpSwap in the DEX view and are not included here.

## Solana trading platform leaderboard: pump.fun vs GMGN vs Axiom vs Fomo, live 24h volume

- Category: Trading
- Metric: 24h volume (usd)
- Page: https://openchainbench.com/benchmarks/solana-trading-platform-wars
- JSON: https://openchainbench.com/api/stat/solana-trading-platform-wars
- Status: live
- Headline: GMGN leads 24h volume at $136.71M (24h) on Solana trading platform leaderboard: pump.fun vs GMGN vs Axiom vs Fomo, live 24h volume.

**Rankings (p50, 24h):**
1. GMGN: $136.71M (p99 $136.71M, success 100.0%, sample 1700980)
2. pump.fun: $100.05M (p99 $100.05M, success 100.0%, sample 935191)
3. Axiom: $58.08M (p99 $58.08M, success 100.0%, sample 1028650)
4. Fomo: $27.78M (p99 $27.78M, success 100.0%, sample 326622)
5. Trojan: $15.15M (p99 $15.15M, success 100.0%, sample 48855.5)
6. Padre: $11.19M (p99 $11.19M, success 100.0%, sample 223636)
7. Photon: $1.88M (p99 $1.88M, success 100.0%, sample 30181)
8. Maestro: $831.2K (p99 $831.2K, success 100.0%, sample 13302.7)

**Methodology**:
- Source: Mobula lighthouse (api.mobula.io/api/2/market/lighthouse), byPlatform field. Mobula attributes swap events using on-chain referral tags, program IDs and memo fields.
- Poll cadence: harness fetches the endpoint every 15 minutes and updates Prometheus gauges. Prometheus scrapes :2112/metrics every 60 seconds.
- Volume: sum of all swap event notional values (in USD at time of swap) within the last 24 hours for swaps attributed to this platform. Higher = more user activity routed through this frontend.
- Attribution: Mobula uses on-chain referral tags, program IDs and memo fields. Each swap is attributed to exactly one platform. Platforms without standard referral tags may be undercounted.
- pump.fun: sourced from Mobula's byLaunchpad bucket (bonding-curve swaps via pump.fun's own frontend). PumpSwap trades routed through GMGN or Axiom count under those platforms.
- Phantom: wallet-initiated swaps via Jupiter or other aggregators, not active trading sessions.

## Crypto trading app iOS ratings: Coinbase vs Robinhood vs Crypto.com vs Bybit, live

- Category: Trading
- Metric: App Store rating (x)
- Page: https://openchainbench.com/benchmarks/app-store-ratings
- JSON: https://openchainbench.com/api/stat/app-store-ratings
- Status: live
- Headline: Fomo leads app store rating at 4.78x (p50, 24h) on Crypto trading app iOS ratings: Coinbase vs Robinhood vs Crypto.com vs Bybit, live.

**Rankings (p50, 24h):**
1. Fomo: 4.78x (p99 4.78x, success 100.0%, sample 8318)
2. Kraken: 4.74x (p99 4.74x, success 100.0%, sample 33746)
3. PumpFun: 4.70x (p99 4.70x, success 100.0%, sample 2335)
4. Bybit: 4.69x (p99 4.69x, success 100.0%, sample 46920)
5. Coinbase: 4.68x (p99 4.68x, success 100.0%, sample 1796400)
6. Crypto.com: 4.66x (p99 4.66x, success 100.0%, sample 332518)
7. Invo: 4.29x (p99 4.29x, success 100.0%, sample 419)
8. Robinhood: 4.29x (p99 4.29x, success 100.0%, sample 4801010)
9. Moonshot: 4.22x (p99 4.22x, success 100.0%, sample 28566)
10. Binance.US: 4.21x (p99 4.21x, success 100.0%, sample 111029)
11. GMGN: 3.69x (p99 3.69x, success 100.0%, sample 81)

**Methodology**:
- Source: Apple iTunes public lookup API (itunes.apple.com/lookup?id=<appID>&country=us). No authentication required. Returns averageUserRating and userRatingCount.
- Poll cadence: harness fetches each app every 30 minutes. Ratings change slowly (daily to weekly) so 30-minute polling captures all meaningful changes while respecting Apple caching.
- Rating: Apple computes the average across all all-time user reviews. Apple does not expose time-windowed (e.g. current version only) averages via the public API endpoint used here.
- Review count: total number of ratings ever submitted on the US App Store. Higher = more statistically reliable average.
- Robinhood (ID 938003185): the most-reviewed financial app on the US App Store with nearly 5 million ratings. Commission-free investing with crypto added in 2018.
- Coinbase (ID 886427730): the largest US-regulated crypto exchange. Over 1.8 million App Store ratings.
- Crypto.com (ID 1262148500): Singapore-headquartered super app with 100M+ users globally, offering spot, derivatives, Visa card and DeFi wallet.
- Bybit (ID 1488296980): major global exchange strong on derivatives and spot trading.
- Kraken (ID 1481947260): veteran US exchange with strong security reputation.
- Binance.US (ID 1492670702): US-regulated arm of Binance, available on the US App Store.
- Fomo (ID 6741115427): launched Apr 2025. Social copy-trading and meme coin terminal, backed by Index Ventures and USV.
- GMGN (ID 6745328711): AI-powered trading terminal focused on Solana meme coins.
- PumpFun (ID 6717572591): launched Oct 2024. Bonding-curve launchpad and trading app for Solana meme coins.
- Moonshot (ID 6503993131): mobile-first meme coin launchpad with fiat onramp via Apple Pay, by DEX Screener.
- Invo (ID 1601301148): Hyperliquid-native social trading mobile app with 170+ perp pairs and copy trading via its registered builder code on Hyperliquid.

## Explicit platform fees for trading memecoins (pump.fun vs Fomo vs Photon vs bots)

- Category: Trading
- Metric: Median fee (pct)
- Page: https://openchainbench.com/benchmarks/memecoin-platforms
- JSON: https://openchainbench.com/api/stat/memecoin-platforms
- Status: live
- Headline: pump.fun leads median fee at 0.12% (24h avg) on Explicit platform fees for trading memecoins (pump.fun vs Fomo vs Photon vs bots).

**Rankings (p50, 24h):**
1. pump.fun: 0.12% (p99 0.25%, success 100.0%, sample 1737.89)
2. Trojan: 0.17% (p99 0.23%, success 100.0%, sample 162.902)
3. Fomo: 0.89% (p99 1.36%, success 100.0%, sample 39.6129)
4. Maestro: 0.96% (p99 1.63%, success 100.0%, sample 2)
5. Axiom: 1.30% (p99 2.21%, success 100.0%, sample 24.8986)
6. Photon: 1.36% (p99 3.35%, success 100.0%, sample 6.80114)
7. GMGN: 1.47% (p99 3.18%, success 100.0%, sample 9.50364)

**Methodology**:
- Fee source (all except Fomo): Dune Analytics query 8316589 on solana.account_activity. Native SOL inflows matched by address = fee wallet; USDC/WSOL inflows matched by token_balance_owner = fee wallet. Summed over NOW() - 1 DAY. Executed every 6h; cached result read every 15min.
- Fee source (Fomo): DeFiLlama /summary/fees/fomo, chainBreakdown[Solana].total24h. DeFiLlama combines on-chain USDC inflows to R4rNJHaffSUotNmqSKNEfDcJE8A7zJUkaoM5Jkd7cYX and off-chain relay fees from dune.tryfomo.fomo_relay_fees (private Dune table).
- Volume source (Mobula): Mobula lighthouse byPlatform for trading terminals; byLaunchpad[name=PumpFun] for pump.fun (bonding curve + PumpSwap graduated AMM). Updated every 15 minutes. This is total attributed volume; includes trades that may not have generated a fee.
- Volume source (fee-paying, Dune): For each transaction that generated a native SOL, USDC, or WSOL inflow to a fee wallet, the largest swap trade in dex_solana.trades with matching tx_id is taken (MAX amount_usd per tx, to avoid double-counting multi-hop routes). Sum across all such transactions = fee_paying_volume_usd_24h. This denominator is self-consistent with the fee numerator.
- Two take-rate metrics: memecoin_platform_fee_rate_pct = fees / Mobula total volume (lower bound, shows attribution breadth); memecoin_platform_fee_paying_rate_pct = fees / fee-paying volume (comparable across platforms, closer to the actual per-trade fee rate). memecoin_platform_coverage_pct = fee-paying volume / Mobula volume (shows what fraction of attributed volume generated a fee).
- SOL price: CoinGecko simple/price, refreshed every 5 minutes. Used to convert native SOL and WSOL inflows to USD.
- GMGN: 9 fee wallets verified by DeFiLlama adapter (master, 2026-06) as pure collectors sweeping to a single treasury. DeFiLlama Solana-only fees match ours within 5%, confirming the wallet list is complete. GMGN's $772K/day DeFiLlama total includes BSC, Base, Ethereum, Monad and other EVM chains; this bench is Solana-only.
- pump.fun: fees captured via native SOL and WSOL inflows to the 9 known protocol fee wallets. pump.fun cut its bonding-curve trading fees to 0% in August 2026; observed fee revenue post that date reflects token graduation fees only. Creator fees (0.30%) and LP fees flow to separate recipients not tracked here.
- Trojan: fee wallets capture the per-swap protocol transfer; DeFiLlama Solana match at 6% confirms fees are in the swap transaction, not a separate settlement.

## Trading app execution quality: Axiom vs GMGN vs Trojan vs Maestro, Solana + EVM

- Category: Trading
- Metric: Avg platform fee (sol)
- Page: https://openchainbench.com/benchmarks/trading-app-execution
- JSON: https://openchainbench.com/api/stat/trading-app-execution
- Status: insufficient
- Headline: Trading app execution quality: Axiom vs GMGN vs Trojan vs Maestro, Solana + EVM. Awaiting first run.
- Insufficient samples to rank providers yet.

**Methodology**:
- Solana source: Helius RPC getSignaturesForAddress on each platform's fee wallet. 100 transactions sampled per poll (every ~5 min).
- Priority fee: transaction fee minus the 5 000-lamport base fee per signature. Paid by the user to compete for block space.
- CU price: priority fee divided by compute units consumed (microlamports/CU). p50/p95 from sampled CU data.
- Jito rate: fraction of sampled transactions tipping one of the 8 official Jito tip accounts.
- Platform fee: average SOL transferred to the platform's fee account per incoming transaction.
- Tx count: total transactions at the fee account over the window, from raw getSignaturesForAddress counts (not just the 100-tx sample).
- EVM source: eth_getLogs for USDC (ERC-20) transfers + native ETH/BNB transfers to each platform's fee address. Base chain: USDC only (no free trace API for native).
- EVM cadence: block-by-block scanning, bootstrapped 30 days back on first run, then continuous.
- All measurements are passive; no test transactions, no funded wallets, no on-chain footprint.

## Solana DEX volume: pump.fun vs Axiom vs GMGN vs Fomo, live 24h

- Category: Trading
- Metric: 24h volume (usd)
- Page: https://openchainbench.com/benchmarks/solana-dex-volume
- JSON: https://openchainbench.com/api/stat/solana-dex-volume
- Status: live
- Headline: GMGN leads 24h volume at $90.34M (24h) on Solana DEX volume: pump.fun vs Axiom vs GMGN vs Fomo, live 24h.

**Rankings (p50, 24h):**
1. GMGN: $90.34M (p99 $90.34M, success 100.0%, sample n/a)
2. pump.fun: $71.85M (p99 $71.85M, success 100.0%, sample n/a)
3. Axiom: $58.23M (p99 $58.23M, success 100.0%, sample n/a)
4. Fomo: $27.57M (p99 $27.57M, success 100.0%, sample n/a)
5. Trojan: $3.24M (p99 $3.24M, success 100.0%, sample n/a)
6. Photon: $1.58M (p99 $1.58M, success 100.0%, sample n/a)
7. BullX: $247.6K (p99 $247.6K, success 100.0%, sample n/a)

**Methodology**:
- Source: DeFiLlama public DEX API (api.llama.fi/summary/dexs/{slug}) and fees API (api.llama.fi/summary/fees/{slug}?dataType=dailyRevenue). No authentication required.
- Poll cadence: harness fetches each platform every 30 minutes and updates Prometheus gauges immediately.
- Volume: total24h and total7d fields from DeFiLlama's DEX endpoint, sum of all swap notional values in USD attributed to this platform.
- Revenue: total24h and total7d from the fees endpoint with dataType=dailyRevenue. This strips LP fees that stay in pool accounts and returns only the protocol's own share. Note: dailyRevenue also nets out referral paybacks (e.g. GMGN nets ~34% back to affiliates) and for pump.fun reflects the buyback-adjusted split introduced in 2026. Use dailyFees if comparing what users pay, not what protocols retain.
- Take rate: protocol revenue divided by trading volume (defillama_dex_fees_24h_usd / defillama_dex_volume_24h_usd). Measures how much of each dollar traded the platform captures.
- Attribution: DeFiLlama uses on-chain referral tags, program IDs and memo fields. Platforms without standard tagging may be undercounted.
- pump.fun (slug pump.fun, layer Launchpad): the original bonding-curve launchpad. Users trade tokens directly on the curve; a token graduates to PumpSwap's AMM at roughly $69K market cap. Cut bonding-curve fees to zero on Aug 7 2026.
- Axiom (slug axiom, layer Terminal): web-based Solana trading terminal. Observed take rate 0.85-1.10% (stated approximately 1%). Revenue briefly overtaken by Fomo on Aug 6 2026.
- GMGN (slug gmgn, layer Terminal): AI-powered trading terminal on Solana. Approximately 1% fee on routed swaps.
- fomo Wallet (slug fomo-wallet, layer Terminal): Fomo's DEX routing layer. Observed take rate approximately 1% on routed swaps. First crossed Axiom on daily revenue Aug 6 2026.
- Trojan (slug trojan, layer Bot): Telegram trading bot on Solana. Lower volume than web terminals but serves a distinct Telegram-native user base.
- Photon (slug photon, layer Terminal): Solana trading terminal targeted at advanced traders.
- BullX (slug bullx, layer Terminal): Solana and multi-chain trading terminal. Volume fell sharply from its 2025 highs after competitors expanded; now a fraction of peak levels.
- PumpSwap is pump.fun's backend AMM where graduated tokens trade. It is not tracked here because its volume overlaps with terminal volume: when Axiom or GMGN route a swap to PumpSwap, that trade appears in both the terminal's figures and PumpSwap's. Tracking PumpSwap alongside the terminals would double-count activity.
- Phantom: Phantom Wallet is the largest Solana wallet by user count but does not have its own DeFiLlama DEX slug. Phantom routes swaps through Jupiter and other aggregators, which appear in those protocols' volume figures.

## Average swap size on Solana: pump.fun vs GMGN vs Fomo vs Axiom, live

- Category: Trading
- Metric: Avg swap size (usd)
- Page: https://openchainbench.com/benchmarks/solana-avg-trade-size
- JSON: https://openchainbench.com/api/stat/solana-avg-trade-size
- Status: live
- Headline: GMGN leads avg swap size at $92.34 (24h) on Average swap size on Solana: pump.fun vs GMGN vs Fomo vs Axiom, live.

**Rankings (p50, 24h):**
1. GMGN: $92.34 (p99 $92.34, success 100.0%, sample 1480550)
2. Maestro: $80.29 (p99 $80.29, success 100.0%, sample 10353)
3. Trojan: $70.41 (p99 $70.41, success 100.0%, sample 215226)
4. Fomo: $67.94 (p99 $67.94, success 100.0%, sample 408930)
5. Bloom: $65.68 (p99 $65.68, success 100.0%, sample 9918)
6. Photon: $58.57 (p99 $58.57, success 100.0%, sample 32072)
7. Phantom: $46.88 (p99 $46.88, success 100.0%, sample 166731)
8. Padre: $46.49 (p99 $46.49, success 100.0%, sample 240746)
9. Axiom: $39.99 (p99 $39.99, success 100.0%, sample 1452350)
10. pump.fun: $29.84 (p99 $29.84, success 100.0%, sample 3352560)

**Methodology**:
- Source: Mobula lighthouse (api.mobula.io/api/2/market/lighthouse), poll every 15 min.
- Average swap size: solana_platform_volume_24h_usd / solana_platform_trades_24h, computed in PromQL.
- Attribution: Mobula assigns each on-chain swap to a platform via referral tags, program IDs and memo fields embedded in transactions. Each swap is attributed to exactly one platform.
- Bot inclusion: all attributed swaps are counted including bots and MEV. Platforms with high bot activity (notably pump.fun snipers) show lower average sizes than human-only baselines would suggest.
- pump.fun: sourced from byLaunchpad (bonding-curve swaps on pump.fun's own site, $123M+ on Aug 13 2026 confirming bonding-curve volume persists under the fee-free model). Trades routed through GMGN or Axiom to pump.fun tokens count under those platforms. Mobula documents trades as swap-level count (not fee-event gated); whether zero-fee swaps post August 7 are indexed identically is an implementation detail not confirmed by docs, pending Mobula support response.
- Meteora DBC excluded: Meteora DBC counts LP provision events and micro-rebalances as trades, making its avg size of ~$12 not comparable to pure swap activity.

## Unique daily swap transactions on Solana: pump.fun vs GMGN vs Fomo vs Axiom vs Trojan, live

- Category: Trading
- Metric: Unique swap tx 24h (count)
- Page: https://openchainbench.com/benchmarks/solana-unique-traders
- JSON: https://openchainbench.com/api/stat/solana-unique-traders
- Status: live
- Headline: pump.fun leads unique swap tx 24h at 7.90M (24h) on Unique daily swap transactions on Solana: pump.fun vs GMGN vs Fomo vs Axiom vs Trojan, live.

**Rankings (p50, 24h):**
1. pump.fun: 7.90M (p99 7.90M, success 100.0%, sample 7898240)
2. Axiom: 1.59M (p99 1.59M, success 100.0%, sample 1594560)
3. Fomo: 384.7K (p99 384.7K, success 100.0%, sample 384722)
4. GMGN: 344.1K (p99 344.1K, success 100.0%, sample 344148)
5. Trojan: 68.3K (p99 68.3K, success 100.0%, sample 68335)
6. Photon: 32.4K (p99 32.4K, success 100.0%, sample 32428)
7. Maestro: 9,774 (p99 9,774, success 100.0%, sample 9774)

**Methodology**:
- Source: Dune Analytics (dune.com). Query updated hourly, results fetched every 15 min.
- Terminals (GMGN, Axiom, Fomo, Trojan, Photon, Maestro): COUNT(DISTINCT tx_id) from solana.account_activity WHERE fee wallet received SOL inflow (address match) or USDC/WSOL inflow (token_balance_owner match) in rolling 24h window.
- pump.fun: COUNT(DISTINCT tx_id) from dex_solana.trades WHERE project IN ('pumpdotfun', 'pumpswap') in rolling 24h window. Covers bonding-curve swaps and graduated PumpSwap AMM trades.
- pump.fun switched from fee wallet to dex_solana.trades on 2026-08-13. The fee wallet approach overcounted by ~60% after the 0% bonding-curve fee cut (2026-08-07), as micro-SOL inflows from rent and account creation triggered false positives on every swap tx.
- Metric represents unique swap transactions per platform. Actual unique-wallet count is 3-10x lower since active traders (and bots) execute multiple transactions per day.
- Bot inclusion: all transactions counted including automated traders, sniping bots, and copy-trade bots.
- Double-count across platforms: a tx touching two fee wallets is counted in both. Counts are not mutually exclusive.

---
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