# OpenChainBench live state

> Auto-refreshed every 60s · last fetch 2026-08-22T00:29:23.330Z · 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 posts the lowest head lag at 0.9 s (p50, 24h) on Fastest crypto price API, live head lag across Mobula, Codex, GeckoTerminal.

**Rankings (p50, 24h):**
1. Mobula: 0.9 s (p99 21 s, success 49.9%, sample 34480)
2. Codex: 1.1 s (p99 29 s, success 49.8%, sample 34423)
3. GeckoTerminal: 18 s (p99 1.7 min, success 49.9%, sample 34474)

**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: deBridge posts the lowest quote latency at 173 ms (p50, 24h) on Fastest cross-chain bridge quote API, live ms ranking.

**Rankings (p50, 24h):**
1. deBridge: 173 ms (p99 1.78 s, success 100.0%, sample 287.1)
2. Near Intents: 357 ms (p99 4.97 s, success 99.7%, sample 286.099)
3. Squid Router: 380 ms (p99 857 ms, success 100.0%, sample 287.1)
4. Relay: 823 ms (p99 3.12 s, success 100.0%, sample 287.1)
5. Mobula: 912 ms (p99 10.00 s, success 100.0%, sample 287.1)
6. Across: 954 ms (p99 6.87 s, success 100.0%, sample 287.1)
7. LI.FI: 1.57 s (p99 4.49 s, success 99.7%, sample 286.099)
8. Socket Protocol: 1.72 s (p99 9.49 s, success 100.0%, sample 287.1)

**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 posts the lowest effective fee at 0.037% (24h avg) on Cheapest cross-chain bridge for USDC at $300 notional.

**Rankings (p50, 24h):**
1. Squid Router: 0.037% (p99 0.060%, success 100.0%, sample 2878)
2. Near Intents: 0.056% (p99 0.058%, success 99.8%, sample 17253)
3. Across: 0.15% (p99 0.16%, success 66.7%, sample 17257)
4. Relay: 0.18% (p99 0.24%, success 99.2%, sample 34509)
5. Mobula: 0.22% (p99 0.23%, success 99.7%, sample 34509)
6. Socket Protocol: 0.28% (p99 0.33%, success 100.0%, sample 2877)
7. LI.FI: 0.45% (p99 0.99%, success 99.9%, sample 34509)
8. deBridge: 1.08% (p99 1.15%, success 100.0%, sample 25884)

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

**Rankings (p50, 24h):**
1. Mobula: 61.0% (p99 65.2%, success 100.0%, sample 88282.7)
2. Codex: 55.4% (p99 65.3%, success 100.0%, sample 88282.7)

**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 463 (24h) on Crypto data API with most blockchains in asset registry, live coverage ranking.

**Rankings (p50, 24h):**
1. CoinGecko: 463 (p99 463, success 100.0%, sample 463)
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 posts the lowest 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.8 s, success 99.4%, sample 207611)
2. BNB: 1.0 s (p99 1.9 s, success 99.6%, sample 171117)
3. Avalanche: 1.7 s (p99 6.0 s, success 99.5%, sample 58324.3)
4. Stellar: 7.1 s (p99 18 s, success 100.0%, sample 11977.2)
5. Solana: 12 s (p99 14 s, success 100.0%, sample 2880)
6. TRON: 57 s (p99 1.0 min, success 100.0%, sample 2880)
7. Ethereum: 15.9 min (p99 19.0 min, success 100.0%, sample 2880)
8. Monero: 20.2 min (p99 40.5 min, success 100.0%, sample 2880)
9. Litecoin: 31.3 min (p99 59.5 min, success 100.0%, sample 2880)
10. Bitcoin: 57.5 min (p99 137.0 min, success 100.0%, sample 136.047)

**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 posts the lowest all-in cost at 0.0022% (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.0022% (p99 0.010%, success 100.0%, sample 2880)
2. Extended: 0.026% (p99 0.036%, success 97.9%, sample 2880)
3. gains.trade: 0.040% (p99 0.040%, success 100.0%, sample 2880)
4. Paradex: 0.040% (p99 0.13%, success 100.0%, sample 2880)
5. Polymarket: 0.044% (p99 0.057%, success 100.0%, sample 2880)
6. Hyperliquid: 0.047% (p99 0.060%, success 100.0%, sample 2880)
7. Aster: 0.052% (p99 0.065%, success 100.0%, sample 2880)
8. GMX v2: 0.060% (p99 0.060%, success 99.7%, sample 2880)
9. dYdX v4: 0.10% (p99 0.21%, success 100.0%, sample 2880)

**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: StellarExpert leads coverage rate at 80.1% (24h avg) on Best wallet labeling API provider.

**Rankings (p50, 24h):**
1. StellarExpert: 80.1% (p99 80.1%, success 80.1%, sample 482.167)
2. XRPScan: 79.6% (p99 79.6%, success 89.9%, sample 486.169)
3. OLI: 50.4% (p99 50.4%, success 100.0%, sample 5584.94)
4. Blockscout: 50.3% (p99 50.3%, success 90.4%, sample 4025.4)
5. Moralis: 45.1% (p99 45.1%, success 99.9%, sample 1312.46)
6. Mobula: 44.2% (p99 44.2%, success 99.7%, sample 8639)
7. TonAPI: 35.9% (p99 35.9%, success 78.7%, sample 676.235)
8. WalletExplorer: 19.9% (p99 19.9%, success 99.8%, sample 488.169)

**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 posts the lowest 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 194 ms, success 100.0%, sample 861185)
2. Arbitrum One: 340 ms (p99 498 ms, success 99.7%, sample 344211)
3. Scroll: 1.62 s (p99 41.32 s, success 99.4%, sample 20450.1)
4. Mantle: 1.87 s (p99 2.98 s, success 99.7%, sample 42953.9)
5. Base: 1.95 s (p99 2.98 s, success 99.9%, sample 43108)
6. Optimism: 1.97 s (p99 2.98 s, success 99.7%, sample 43011.9)
7. Taiko: 1.98 s (p99 3.50 s, success 99.6%, sample 42307.7)
8. Blast: 1.99 s (p99 2.98 s, success 99.8%, sample 43104)
9. zkSync Era: 2.26 s (p99 29.29 s, success 99.7%, sample 20152)
10. Linea: 4.48 s (p99 27.63 s, success 99.7%, sample 14436)

**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 posts the lowest rpc latency at 73 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: 73 ms (p99 388 ms, success 100.0%, sample 4316.84)
2. Avalanche: 178 ms (p99 638 ms, success 100.0%, sample 4317.84)
3. dRPC: 230 ms (p99 641 ms, success 85.6%, sample 289174)
4. PublicNode: 244 ms (p99 2.06 s, success 80.5%, sample 276084)
5. Base: 259 ms (p99 520 ms, success 100.0%, sample 4318.84)
6. Lava: 274 ms (p99 2.23 s, success 99.1%, sample 30194.9)
7. Arbitrum: 278 ms (p99 2.37 s, success 98.9%, sample 4318.89)
8. Nodies: 302 ms (p99 2.02 s, success 66.1%, sample 25879.2)
9. Tenderly: 307 ms (p99 385 ms, success 96.5%, sample 125194)
10. Optimism: 332 ms (p99 386 ms, success 99.9%, sample 4315.84)
11. MeowRPC: 383 ms (p99 2.49 s, success 97.7%, sample 8623.73)
12. Flashbots: 707 ms (p99 1.02 s, success 100.0%, sample 4317.84)

**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)
- Page: https://openchainbench.com/benchmarks/gas-estimation
- JSON: https://openchainbench.com/api/stat/gas-estimation
- Status: live
- Headline: PublicNode posts the lowest gap vs realized at 0.011 gwei (p50, 24h) on Most accurate gas oracle, live gap vs realized priority fee.

**Rankings (p50, 24h):**
1. PublicNode: 0.011 gwei (p99 0 gwei, success 99.1%, sample 28797)
2. MetaMask: 0.011 gwei (p99 0 gwei, success 100.0%, sample 28798)
3. Owlracle: 0.015 gwei (p99 ~0 gwei, success 97.5%, sample 5759)
4. Etherscan: 0.018 gwei (p99 0 gwei, success 99.8%, sample 17279)

**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 posts the lowest peg deviation at 0.00081% (24h avg) on Most stable stablecoin, live peg deviation across USDC, USDT and DAI.

**Rankings (p50, 24h):**
1. DAI: 0.00081% (p99 0.0028%, success 100.0%, sample 7200.5)
2. USDC: 0.015% (p99 0.015%, success 100.0%, sample 51839)
3. USDT: 0.043% (p99 0.067%, success 100.0%, sample 51839)

**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: USDe posts the lowest usdt-pair spread at 0.015% (24h avg) on Cheapest USDT stablecoin swap on Binance, live USDC, FDUSD, USDe spread.

**Rankings (p50, 24h):**
1. USDe: 0.015% (p99 0.025%, success 100.0%, sample 17280)
2. USDC: 0.030% (p99 0.053%, success 100.0%, sample 17280)
3. FDUSD: 0.12% (p99 0.15%, 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 143.3% (24h avg) on DeFi token buyback tracker, live executed vs promised ratio.

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

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

**Rankings (p50, 24h):**
1. BTC/USD: 0.040% (p99 0.12%, success 100.0%, sample 11520)
2. AVAX/USD: 0.041% (p99 0.15%, success 100.0%, sample 11520)
3. ETH/USD: 0.042% (p99 0.12%, success 100.0%, sample 11520)
4. BNB/USD: 0.042% (p99 0.11%, success 100.0%, sample 11520)
5. SOL/USD: 0.044% (p99 0.12%, success 100.0%, sample 11520)
6. LINK/USD: 0.047% (p99 0.20%, success 100.0%, sample 11520)
7. DOGE/USD: 0.047% (p99 0.17%, success 100.0%, sample 8640)
8. ADA/USD: 0.050% (p99 0.20%, success 100.0%, sample 8640)
9. XRP/USD: 0.050% (p99 0.20%, success 100.0%, sample 8640)
10. POL/USD: 0.062% (p99 0.26%, success 100.0%, sample 11520)

**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.69% (24h avg) on Highest staking yield, live validator net APR across 7 PoS chains.

**Rankings (p50, 24h):**
1. Cosmos Hub: 9.69% (p99 9.69%, success 100.0%, sample 200)
2. Avalanche: 6.80% (p99 8.33%, success 100.0%, sample 100)
3. Solana: 5.13% (p99 5.43%, success 99.9%, 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)
- Page: https://openchainbench.com/benchmarks/hyperliquid-frontends
- JSON: https://openchainbench.com/api/stat/hyperliquid-frontends
- Status: live
- Headline: MetaMask leads builder fees collected at $133.8K (24h) on Hyperliquid frontends builder revenue leaderboard.

**Rankings (p50, 24h):**
1. MetaMask: $133.8K (p99 $57.24, success 100.0%, sample 36018)
2. Phantom: $113.9K (p99 $17.21, success 100.0%, sample 97614)
3. Trust Wallet: $89.6K (p99 $40.22, success 100.0%, sample 40242)
4. Invo: $48.5K (p99 $4.88, success 100.0%, sample 158132)
5. based.app: $46.8K (p99 $89.06, success 100.0%, sample 15961)
6. FOMO: $43.5K (p99 $16.35, success 100.0%, sample 43332)
7. 0xdbc2…97a6: $30.7K (p99 $197, success 100.0%, sample 2358)
8. Rabby: $25.9K (p99 $18.83, success 100.0%, sample 35397)
9. Insilico: $15.2K (p99 $48.22, success 100.0%, sample 62430)
10. Moonbot: $14.3K (p99 $140.63, success 100.0%, sample 21519)
11. Bitget Wallet: $13.3K (p99 $30.27, success 100.0%, sample 6981)
12. Liquid Perps: $11.4K (p99 $21.45, success 100.0%, sample 13372)
13. OneKey: $11.1K (p99 $54.8, success 100.0%, sample 4558)
14. MetaMask (alt): $8,455.99 (p99 $53.86, success 100.0%, sample 3914)
15. Hyperdash: $8,085.28 (p99 $27.78, success 100.0%, sample 31487)
16. Markets Mobile: $7,113.15 (p99 $51.92, success 100.0%, sample 4307)
17. Metascalp: $6,566.94 (p99 $24.69, success 100.0%, sample 52301)
18. 0x7cc0…e781: $5,961.38 (p99 $1.69, success 100.0%, sample 26762)
19. Rainbow: $5,531.24 (p99 $40.37, success 100.0%, sample 1831)
20. Wallet V: $5,524.55 (p99 $212.48, success 100.0%, sample 1859)
21. Dreamcash: $5,030.64 (p99 $13.52, success 100.0%, sample 4518)
22. Mass.money: $4,199.32 (p99 $38.53, success 100.0%, sample 4739)
23. 0x9f83…31d9: $3,582.64 (p99 $31.43, success 100.0%, sample 1871)
24. BullpenFi: $3,375.44 (p99 $26.37, success 100.0%, sample 5099)
25. Tread.fi: $2,976.21 (p99 $29.47, success 100.0%, sample 95371)
26. cro.trade: $2,873.27 (p99 $151.23, success 100.0%, sample 691)
27. 0x53a1…fcd1: $2,122.91 (p99 $21.23, success 100.0%, sample 1989)
28. Pear: $2,012.33 (p99 $27.57, success 100.0%, sample 12541)
29. Infinex: $1,971.11 (p99 $43.8, success 100.0%, sample 2275)
30. 0x42f3…f992: $1,913.19 (p99 $14.83, success 100.0%, sample 4824)
31. Axiom: $1,902.91 (p99 $3.95, success 100.0%, sample 8898)
32. Dexly Trade: $1,847.9 (p99 $27.58, success 100.0%, sample 1100)
33. Legend Trade: $1,794.89 (p99 $11.51, success 100.0%, sample 3718)
34. 0xc95d…1aca: $1,673.31 (p99 $119.52, success 100.0%, sample 25283)
35. 0xf85a…5688: $1,517.47 (p99 $52.33, success 100.0%, sample 1288)
36. pvp.trade: $1,124.24 (p99 $16.06, success 100.0%, sample 1047)
37. UnityWallet: $1,062.17 (p99 $265.54, success 100.0%, sample 296)
38. Dexari: $976.89 (p99 $31.51, success 100.0%, sample 611)
39. Senpi: $911.75 (p99 $6.75, success 100.0%, sample 2407)
40. ApexLiquid: $859.11 (p99 $7.34, success 100.0%, sample 6905)
41. XBIT: $721.15 (p99 $42.42, success 100.0%, sample 185)
42. Nansen: $672.74 (p99 $5.95, success 100.0%, sample 1561)
43. goodcryptoX: $609.66 (p99 $7.62, success 100.0%, sample 3188)
44. Arena: $558.41 (p99 $39.89, success 100.0%, sample 237)
45. Dextrabot: $391.68 (p99 $6.53, success 100.0%, sample 4406)
46. HyperX: $360.2 (p99 $4.05, success 100.0%, sample 8972)
47. Owly.fi: $359.38 (p99 $29.95, success 100.0%, sample 8843)
48. Wunder: $334.52 (p99 $2.44, success 100.0%, sample 5349)
49. tuleep.trade: $314.39 (p99 $52.4, success 100.0%, sample 5954)
50. 0x446f…d6c6: $301.45 (p99 $150.73, success 100.0%, sample 367)
51. defi.app: $224.83 (p99 $5.23, success 100.0%, sample 503)
52. CCXT: $204.28 (p99 $2.43, success 100.0%, sample 8090)
53. STRYX: $195.56 (p99 $97.78, success 100.0%, sample 85)
54. MinaraAI: $156.11 (p99 $0.2783, success 100.0%, sample 4299)
55. Onchain.cc: $135.29 (p99 $0.4797, success 100.0%, sample 2265)
56. Splash: $134.71 (p99 $16.84, success 100.0%, sample 270)
57. Moontrader: $129.59 (p99 $21.6, success 100.0%, sample 219)
58. SuperCEXy: $109.89 (p99 $9.99, success 100.0%, sample 709)
59. CoinPilot: $103.45 (p99 $1.4, success 100.0%, sample 3224)
60. VergeX: $89.6 (p99 $0.9634, success 100.0%, sample 843)
61. Sushi: $78.44 (p99 $15.69, success 100.0%, sample 34)
62. Miracle: $74.98 (p99 $3.41, success 100.0%, sample 253)
63. KuCoin Web3: $70.18 (p99 $17.55, success 100.0%, sample 24)
64. Origami Tech: $65.93 (p99 $13.19, success 100.0%, sample 3174)
65. Tradoor: $53.82 (p99 $6.73, success 100.0%, sample 2747)
66. Okto: $49.02 (p99 $1.23, success 100.0%, sample 248)
67. MarsGO: $47.56 (p99 $9.51, success 100.0%, sample 98)
68. DeFi Saver: $28.08 (p99 $2.81, success 100.0%, sample 66)
69. PerpsWLD: $26.58 (p99 $2.42, success 100.0%, sample 109)
70. Hyprearn: $25.93 (p99 $1.85, success 100.0%, sample 287)
71. GTR Trade: $17.93 (p99 $5.98, success 100.0%, sample 89)
72. Liminal: $16.09 (p99 $1.24, success 100.0%, sample 110)
73. Cwallet: $14.89 (p99 $1.35, success 100.0%, sample 100)
74. Lit Trade: $7.8 (p99 $1.56, success 100.0%, sample 67)
75. VOOI: $1.51 (p99 $0.2522, success 100.0%, sample 106)
76. Gem Wallet: $0.8553 (p99 $0.2851, success 100.0%, sample 12)
77. Grider: $0.7583 (p99 $0.7583, success 100.0%, sample 134)
78. Katoshi: $0.00928 (p99 $0.00928, success 100.0%, sample 1)
79. UXUY: $0.00765 (p99 $0.00765, success 100.0%, sample 1)

**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 posts the lowest native transfer fee usd at $0.000114 (24h) on Cheapest blockchain transaction fee, live across 15 L1 and L2 chains.

**Rankings (p50, 24h):**
1. Litecoin: $0.000114 (p99 $0.000121, success 99.9%, sample 6784)
2. Base: $0.000302 (p99 $0.00628, success 100.0%, sample 6784)
3. Taiko: $0.000441 (p99 $0.00322, success 100.0%, sample 6784)
4. Solana: $0.000455 (p99 $0.00318, success 100.0%, sample 6784)
5. Mantle: $0.000544 (p99 $0.00421, success 100.0%, sample 6784)
6. BNB Chain: $0.000757 (p99 $0.0267, success 100.0%, sample 6784)
7. Arbitrum One: $0.00101 (p99 $0.00109, success 100.0%, sample 6784)
8. Robinhood Chain: $0.00101 (p99 $0.00108, success 100.0%, sample 6784)
9. zkSync Era: $0.00227 (p99 $0.00241, success 100.0%, sample 6784)
10. Linea: $0.00878 (p99 $0.0618, success 100.0%, sample 6784)
11. Ethereum: $0.0354 (p99 $1.63, success 100.0%, sample 6784)
12. Cardano: $0.0357 (p99 $0.0386, success 100.0%, sample 6784)
13. Monero: $0.0495 (p99 $0.2012, success 99.8%, sample 6784)
14. TRON: $0.0937 (p99 $0.0937, success 100.0%, sample 6784)

**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: KyberSwap posts the lowest quote latency at 252 ms (p50, 24h) on Fastest EVM swap quote API.

**Rankings (p50, 24h):**
1. KyberSwap: 252 ms (p99 3.07 s, success 99.6%, sample 4301.53)
2. Mobula: 425 ms (p99 2.56 s, success 99.5%, sample 4299.53)
3. Bebop: 701 ms (p99 3.37 s, success 98.6%, sample 4266.52)
4. LI.FI: 742 ms (p99 2.50 s, success 62.4%, sample 2697.33)
5. Enso: 1.36 s (p99 4.58 s, success 98.4%, sample 4262.52)
6. CoW Protocol: 2.87 s (p99 4.96 s, success 100.0%, sample 3456.42)

**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 posts the lowest token deployment cost usd at $0.00120 (24h) on Cheapest blockchain to deploy a token, live USD cost across 7 non-EVM L1 chains.

**Rankings (p50, 24h):**
1. Osmosis: $0.00120 (p99 $0.00137, success 100.0%, sample 10591)
2. Aptos: $0.0939 (p99 $0.0981, success 100.0%, sample 10591)
3. Cardano: $0.2515 (p99 $0.2719, success 100.0%, sample 10601)
4. Sui: $0.3978 (p99 $61.15, success 100.0%, sample 10601)
5. Stellar: $0.4777 (p99 $0.5076, success 100.0%, sample 10601)
6. Injective: $0.4909 (p99 $0.5065, success 100.0%, sample 10601)
7. Solana: $0.8305 (p99 $0.8611, success 100.0%, sample 10591)

**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)
- 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 at $132.2K (24h) on Hyperliquid HIP-3 deployer revenue leaderboard.

**Rankings (p50, 24h):**
1. trade.xyz: $132.2K (p99 $0.2193, success 100.0%, sample 4138790)
2. Paragon: $967.47 (p99 $0.4804, success 100.0%, sample 210834)
3. HyENA: $378.86 (p99 $0.1589, success 100.0%, sample 37964)

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

**Rankings (p50, 24h):**
1. OKX: 2.98 bps (p99 3.00 bps, success 100.0%, sample 2880)
2. Binance: 3.00 bps (p99 3.00 bps, success 100.0%, sample 2880)
3. Polymarket: 3.00 bps (p99 3.00 bps, success 100.0%, sample 2880)
4. Aster: 3.00 bps (p99 3.00 bps, success 100.0%, sample 2880)
5. Paradex: 3.12 bps (p99 3.00 bps, success 100.0%, sample 2880)
6. Hyperliquid: 3.84 bps (p99 4.82 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: Polymarket posts the lowest warm book latency at 200 ms (p50, 24h) on Prediction market API rate limits, tested with a daily ramp.

**Rankings (p50, 24h):**
1. Polymarket: 200 ms (p99 250 ms, success 100.0%, sample 51835.8)
2. Kalshi: 265 ms (p99 400 ms, success 100.0%, sample 51830.8)
3. Limitless: 316 ms (p99 1.12 s, success 100.0%, sample 51837.8)
4. Manifold: 500 ms (p99 9.88 s, success 98.5%, sample 36966.8)
5. Myriad: 1.26 s (p99 2.83 s, success 99.4%, sample 51702.7)

**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 posts the lowest api latency (price endpoint) at 94 ms (p50, 24h) on Best prediction market API, ranked by live latency and uptime.

**Rankings (p50, 24h):**
1. Limitless: 94 ms (p99 476 ms, success 100.0%, sample 51839.8)
2. Polymarket: 200 ms (p99 249 ms, success 100.0%, sample 51837.8)
3. Kalshi: 278 ms (p99 400 ms, success 100.0%, sample 51832.8)
4. Manifold: 325 ms (p99 399 ms, success 98.5%, sample 36967.8)
5. Myriad: 1.26 s (p99 2.83 s, success 99.4%, sample 51702.7)

**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 posts the lowest resolution delay at 9.3 min (p50, 24h) on Resolution delay, Polymarket vs Kalshi.

**Rankings (p50, 24h):**
1. Kalshi — All: 9.3 min (p99 14.9 min, success 100.0%, sample 57)
2. Kalshi — Sports: 9.3 min (p99 14.9 min, success 100.0%, sample 57)
3. Polymarket — Crypto: 10.1 min (p99 28.1 min, success 100.0%, sample 10776)
4. Polymarket — Sports: 58.8 min (p99 238.2 min, success 100.0%, sample 133134)
5. Polymarket — All: 124.2 min (p99 238.9 min, success 100.0%, sample 190994)
6. Polymarket — Other: 158.5 min (p99 292.5 min, success 100.0%, sample 46054)
7. Polymarket — Politics: 184.7 min (p99 654.1 min, success 100.0%, sample 1030)

**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 3671.27)
2. OpenSea: 95.4% (p99 95.4%, success 100.0%, sample 4301.49)
3. Alchemy: 75.1% (p99 75.1%, success 100.0%, sample 5997.08)

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

**Rankings (p50, 24h):**
1. Hyperliquid: $13.56B (p99 $16.17B, success 85.7%, sample 2880)
2. Aster: $4.46B (p99 $5.55B, success 85.7%, sample 2880)
3. Lighter: $2.52B (p99 $2.82B, success 85.7%, sample 2880)
4. Pacifica: $1.36B (p99 $1.44B, success 85.7%, sample 2880)
5. GRVT: $618.53M (p99 $670.46M, success 71.4%, sample 2880)
6. Extended: $612.87M (p99 $687.33M, success 84.7%, sample 2880)
7. Vertex: $409.13M (p99 $763.54M, success 85.7%, sample 2880)
8. Polymarket: $268.39M (p99 $298.43M, success 79.9%, sample 2880)
9. Backpack: $257.86M (p99 $312.27M, success 50.0%, sample 2880)
10. GMX V2: $210.57M (p99 $252.04M, success 66.7%, sample 2880)
11. dYdX v4: $105.49M (p99 $132.33M, success 85.7%, sample 2880)
12. Gains Network: $45.84M (p99 $55.97M, success 83.3%, sample 2880)
13. Orderly: $44.23M (p99 $96.52M, success 50.0%, sample 2880)
14. Paradex: $19.93M (p99 $25.39M, success 85.7%, sample 2880)
15. Aevo: $2.59M (p99 $4.16M, success 71.3%, sample 2880)

**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.
- GMX V2: stats.gmx.io hourly-volume API (groupPeriod=3600) for Arbitrum and Avalanche; last 24 hourly buckets summed for the rolling 24h notional in USD.
- Gains Network: backend-arbitrum and backend-polygon REST APIs, lastDayVolume summed across both chains 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.
- Orderly: public volume/stats endpoint at api-evm.orderly.org; perp_volume_last_1_day gives rolling 24h USD notional across all EVM chains.
- Backpack: public tickers endpoint at api.backpack.exchange; quoteVolume summed across all *_PERP symbols in USDC.
- 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 AMM volume share, live 24h notional ranked

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

**Rankings (p50, 24h):**
1. Pacifica: $1.36B (p99 $1.44B, success 85.7%, sample 2880)
2. GMX V2: $210.57M (p99 $252.04M, success 66.7%, sample 2880)
3. Gains Network: $45.84M (p99 $55.97M, success 83.3%, sample 2880)
4. Ostium: $13.33M (p99 $32.94M, success 83.3%, sample 2880)

**Methodology**:
- Cadence: every 5 minutes per venue in parallel, 15 second timeout per request.
- GMX V2: public Subsquid squid at gmx.squids.live for Arbitrum and Avalanche; queries the most recent 1d volume bucket where timestamp >= now-86400, sums both chains in USD. volumeUsd is a BigInt scaled 1e30; dividing by 1e30 yields USD.
- Gains Network: stats.gains.trade/volume REST endpoint; totalVolume field gives rolling 24h notional in USD across all chains.
- Ostium: Ormi-hosted subgraph (api.subgraph.ormilabs.com); sums trade.notional for all trades opened in the last 24h (timestamp_gte=now-86400); notional is in USDC internal units (1e6 per USD).
- Pacifica: onchain reads on the Solana program state for trailing 24h taker notional.
- SynFutures: CoinGecko public derivatives exchange endpoint (id=synfutures); trade_volume_24h_btc multiplied by BTC/USD spot price from CoinGecko simple/price. SynFutures uses the oAMM (Oyster AMM) model on Base and Arbitrum.
- KiloEx: CoinGecko public derivatives exchange endpoint summed across three chains (kiloex-bsc, kiloex-base, kiloex-opbnb); trade_volume_24h_btc summed then multiplied by BTC/USD spot price. KiloEx is an oracle-based AMM perp DEX.
- 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: Binance posts the lowest 24h eth funding stddev at 0.00020% (24h avg) on Perp DEX funding stability, 24h stddev of ETH funding ranked.

**Rankings (p50, 24h):**
1. Binance: 0.00020% (p99 0%, success 100.0%, sample 2880)
2. OKX: 0.00065% (p99 0%, success 100.0%, sample 2880)
3. MEXC: 0.0014% (p99 0%, success 100.0%, sample 2880)
4. Gate: 0.0028% (p99 0.00060%, success 100.0%, sample 2880)
5. Bitget: 0.0032% (p99 0%, success 100.0%, sample 2880)
6. Paradex: 0.0037% (p99 0.00002%, success 100.0%, sample 2880)
7. KuCoin: 0.0061% (p99 0%, success 100.0%, sample 2880)
8. Lighter: 0.0093% (p99 0.0034%, success 100.0%, sample 2880)
9. Coinbase: 0.012% (p99 0.0035%, success 100.0%, sample 2880)
10. Hyperliquid: 0.028% (p99 0.034%, success 100.0%, sample 2880)
11. Kraken: 0.034% (p99 0.069%, success 100.0%, sample 2880)
12. dYdX v4: 0.043% (p99 0.0012%, 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: dRPC posts the lowest rpc latency at 16 ms (p50, 24h) on Fastest free Ethereum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 16 ms (p99 407 ms, success 90.1%, sample 4313.84)
2. PublicNode: 121 ms (p99 4.00 s, success 97.2%, sample 4315.85)
3. Tenderly: 244 ms (p99 293 ms, success 100.0%, sample 4317.84)
4. Nodies: 265 ms (p99 1.92 s, success 99.6%, sample 4314.86)
5. Lava: 366 ms (p99 2.46 s, success 98.4%, sample 4315.84)
6. MeowRPC: 367 ms (p99 2.34 s, success 98.1%, sample 4311.87)

**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 posts the lowest rpc latency at 108 ms (p50, 24h) on Fastest free Arbitrum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 108 ms (p99 1.86 s, success 98.6%, sample 4312.88)
2. Tenderly: 240 ms (p99 275 ms, success 99.9%, sample 4314.84)
3. Nodies: 256 ms (p99 2.20 s, success 98.8%, sample 4315.87)
4. Arbitrum: 278 ms (p99 2.37 s, success 98.9%, sample 4318.89)
5. Lava: 288 ms (p99 4.22 s, success 96.8%, sample 4310.84)
6. dRPC: 351 ms (p99 996 ms, success 88.1%, sample 4312.84)
7. MeowRPC: 398 ms (p99 2.65 s, success 97.4%, sample 4311.86)

**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 posts the lowest rpc latency at 124 ms (p50, 24h) on Fastest free Base RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 124 ms (p99 1.71 s, success 99.3%, sample 4312.86)
2. dRPC: 169 ms (p99 476 ms, success 72.1%, sample 4316.84)
3. Tenderly: 245 ms (p99 462 ms, success 100.0%, sample 4314.84)
4. Base: 259 ms (p99 507 ms, success 100.0%, sample 4318.84)
5. Nodies: 345 ms (p99 1.98 s, success 99.1%, sample 4306.85)

**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 posts the lowest rpc latency at 104 ms (p50, 24h) on Fastest free Optimism RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 104 ms (p99 1.94 s, success 99.2%, sample 4314.86)
2. dRPC: 166 ms (p99 401 ms, success 70.2%, sample 4320.84)
3. Tenderly: 240 ms (p99 273 ms, success 100.0%, sample 4317.84)
4. Optimism: 332 ms (p99 386 ms, success 99.9%, sample 4315.84)
5. Nodies: 340 ms (p99 1.97 s, success 99.1%, sample 4313.87)

**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 posts the lowest rpc latency at 107 ms (p50, 24h) on Fastest free Avalanche RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 107 ms (p99 1.24 s, success 99.1%, sample 4315.87)
2. Avalanche: 178 ms (p99 638 ms, success 100.0%, sample 4317.84)
3. dRPC: 198 ms (p99 380 ms, success 89.5%, sample 4316.84)
4. Tenderly: 330 ms (p99 374 ms, success 100.0%, sample 4321.84)

**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 posts the lowest rpc latency at 73 ms (p50, 24h) on Fastest free BNB Chain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Binance: 73 ms (p99 388 ms, success 100.0%, sample 4316.84)
2. PublicNode: 106 ms (p99 2.13 s, success 98.9%, sample 4314.85)

**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 posts the lowest rpc latency at 15 ms (p50, 24h) on Fastest free Polygon RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 15 ms (p99 414 ms, success 100.0%, sample 4311.84)
2. PublicNode: 106 ms (p99 2.25 s, success 98.7%, sample 4318.84)
3. Tenderly: 242 ms (p99 274 ms, success 100.0%, sample 4311.84)

**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 posts the lowest rpc latency at 103 ms (p50, 24h) on Fastest free Linea RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 103 ms (p99 2.53 s, success 99.7%, sample 4308.85)
2. dRPC: 194 ms (p99 576 ms, success 89.2%, sample 4313.84)
3. Tenderly: 327 ms (p99 400 ms, success 100.0%, sample 4321.84)

**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 posts the lowest rpc latency at 114 ms (p50, 24h) on Fastest free Scroll RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 114 ms (p99 2.34 s, success 99.3%, sample 4314.84)
2. dRPC: 212 ms (p99 673 ms, success 89.1%, sample 4320.84)
3. Tenderly: 327 ms (p99 406 ms, success 100.0%, sample 4321.84)

**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 posts the lowest rpc latency at 22 ms (p50, 24h) on Fastest free Mantle RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 22 ms (p99 451 ms, success 90.3%, sample 4311.84)
2. PublicNode: 108 ms (p99 1.82 s, success 99.4%, sample 4318.84)
3. Tenderly: 330 ms (p99 411 ms, success 100.0%, sample 4312.84)

**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 posts the lowest effective slippage at 0.18% (24h avg) on Best DEX for a $BOT market order, live slippage ranked.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.18% (p99 0.39%, success 100.0%, sample 2123)
2. Lighter: 1.49% (p99 8.32%, success 100.0%, sample 2880)

**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 posts the lowest rpc latency at 110 ms (p50, 24h) on Fastest free Sonic RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 110 ms (p99 2.34 s, success 99.0%, sample 4310.87)
2. dRPC: 200 ms (p99 360 ms, success 90.2%, sample 4311.84)
3. Sonic Labs: 245 ms (p99 280 ms, success 100.0%, sample 4318.84)
4. Tenderly: 329 ms (p99 381 ms, success 100.0%, sample 4313.84)
5. Lava: 447 ms (p99 2.65 s, success 100.0%, sample 4310.84)

**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 posts the lowest rpc latency at 108 ms (p50, 24h) on Fastest free Gnosis RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 108 ms (p99 1.96 s, success 99.2%, sample 4316.85)
2. dRPC: 168 ms (p99 482 ms, success 90.9%, sample 4318.84)
3. Tenderly: 329 ms (p99 401 ms, success 100.0%, sample 4317.84)
4. Gnosis: 336 ms (p99 1.28 s, success 100.0%, sample 4315.84)

**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: Celo (Forno) posts the lowest rpc latency at 198 ms (p50, 24h) on Fastest free Celo RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Celo (Forno): 198 ms (p99 588 ms, success 99.5%, sample 4316.84)
2. dRPC: 224 ms (p99 1.02 s, success 81.6%, sample 4317.84)
3. PublicNode: 261 ms (p99 1.88 s, success 99.0%, sample 4314.86)
4. Tenderly: 330 ms (p99 371 ms, success 100.0%, sample 4312.84)

**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 posts the lowest rpc latency at 263 ms (p50, 24h) on Fastest free Moonbeam RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 263 ms (p99 1.52 s, success 91.4%, sample 4304.1)

**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 posts the lowest rpc latency at 122 ms (p50, 24h) on Fastest free Unichain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 122 ms (p99 2.27 s, success 98.7%, sample 4313.86)
2. dRPC: 168 ms (p99 442 ms, success 90.1%, sample 4313.84)
3. Unichain: 248 ms (p99 299 ms, success 100.0%, sample 4312.84)
4. Tenderly: 328 ms (p99 362 ms, success 100.0%, sample 4313.84)

**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 posts the lowest rpc latency at 2 ms (p50, 24h) on Fastest free Blast RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Blast: 2 ms (p99 11 ms, success 100.0%, sample 4312.84)
2. PublicNode: 103 ms (p99 1.79 s, success 99.3%, sample 4309.87)
3. dRPC: 200 ms (p99 451 ms, success 89.9%, sample 4313.84)
4. Tenderly: 329 ms (p99 375 ms, success 100.0%, sample 4322.84)

**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 posts the lowest rpc latency at 147 ms (p50, 24h) on Fastest free Taiko RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 147 ms (p99 1.95 s, success 99.6%, sample 4313.84)
2. Taiko: 218 ms (p99 862 ms, success 100.0%, sample 4311.84)
3. dRPC: 235 ms (p99 334 ms, success 82.2%, sample 4317.84)
4. Tenderly: 326 ms (p99 372 ms, success 100.0%, sample 4316.84)

**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 posts the lowest rpc latency at 178 ms (p50, 24h) on Fastest free Berachain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Berachain: 178 ms (p99 790 ms, success 98.7%, sample 4317.84)
2. dRPC: 234 ms (p99 761 ms, success 71.9%, sample 4311.84)
3. PublicNode: 259 ms (p99 1.93 s, success 99.7%, sample 4312.85)
4. Tenderly: 327 ms (p99 372 ms, success 100.0%, sample 4317.84)

**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 posts the lowest 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 481 ms, success 90.5%, sample 4316.84)
2. zkSync: 219 ms (p99 859 ms, success 99.9%, sample 4314.84)
3. Tenderly: 333 ms (p99 388 ms, success 100.0%, sample 4322.84)

**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 posts the lowest rpc latency at 30 ms (p50, 24h) on Fastest free Cronos RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Cronos: 30 ms (p99 2.09 s, success 98.5%, sample 4304.87)
2. PublicNode: 200 ms (p99 1.56 s, success 99.6%, sample 4310.87)
3. dRPC: 255 ms (p99 462 ms, success 90.4%, sample 4312.84)

**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 posts the lowest rpc latency at 70 ms (p50, 24h) on Fastest free Fraxtal RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Fraxtal: 70 ms (p99 2.04 s, success 98.9%, sample 4315.86)
2. dRPC: 168 ms (p99 476 ms, success 90.8%, sample 4311.84)
3. PublicNode: 266 ms (p99 1.80 s, success 99.7%, sample 4314.87)
4. Tenderly: 330 ms (p99 618 ms, success 100.0%, sample 4318.84)

**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 posts the lowest rpc latency at 82 ms (p50, 24h) on Fastest free Soneium RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Soneium: 82 ms (p99 1.27 s, success 99.6%, sample 4308.05)
2. PublicNode: 110 ms (p99 1.85 s, success 99.1%, sample 4315.85)
3. dRPC: 205 ms (p99 913 ms, success 89.1%, sample 4313.84)
4. Tenderly: 330 ms (p99 513 ms, success 100.0%, sample 4317.84)

**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 posts the lowest rpc latency at 2 ms (p50, 24h) on Fastest free Monad RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Monad: 2 ms (p99 16 ms, success 99.6%, sample 4308.84)
2. OnFinality: 126 ms (p99 2.22 s, success 100.0%, sample 4317.84)
3. dRPC: 187 ms (p99 223 ms, success 99.3%, sample 4316.84)
4. Tenderly Gateway: 330 ms (p99 398 ms, success 100.0%, sample 4317.84)

**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 posts the lowest rpc latency at 21 ms (p50, 24h) on Fastest free MegaETH RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. MegaETH Official: 21 ms (p99 50 ms, success 100.0%, sample 4317.84)
2. dRPC: 168 ms (p99 477 ms, success 90.7%, sample 4316.84)
3. Tenderly Gateway: 330 ms (p99 374 ms, success 100.0%, sample 4320.84)

**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 posts the lowest wallet call latency at 9 ms (p50, 24h) on Fastest MEV protection RPC, live wallet latency and method coverage.

**Rankings (p50, 24h):**
1. bloXroute Protect: 9 ms (p99 23 ms, success 98.8%, sample 60371)
2. PancakeSwap MEV Guard: 22 ms (p99 34 ms, success 100.0%, sample 30185.4)
3. 48 Club Privacy RPC: 23 ms (p99 29 ms, success 99.9%, sample 30185.4)
4. MEV Blocker: 36 ms (p99 52 ms, success 100.0%, sample 30186.6)
5. Flashbots Protect: 101 ms (p99 111 ms, success 83.3%, sample 30187.7)
6. Blink: 102 ms (p99 112 ms, success 98.7%, sample 90556.6)
7. BlockSec Anti-MEV: 105 ms (p99 113 ms, success 99.5%, sample 60369.9)

**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 posts the lowest rpc latency at 115 ms (p50, 24h) on Fastest free Solana RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Solana: 115 ms (p99 807 ms, success 100.0%, sample 4313.84)
2. PublicNode: 121 ms (p99 2.94 s, success 95.4%, sample 4309.86)
3. Lava: 221 ms (p99 1.89 s, success 99.0%, sample 4311.84)
4. Solana Vibe Station: 223 ms (p99 964 ms, success 100.0%, sample 4317.84)

**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: META posts the lowest price deviation at 0.054% (24h avg) on Tokenized stock price accuracy, live onchain vs Nasdaq across 11 equities.

**Rankings (p50, 24h):**
1. META: 0.054% (p99 0.39%, success 100.0%, sample 10601)
2. NVDA: 0.19% (p99 0.41%, success 100.0%, sample 10601)
3. PLTR: 0.27% (p99 1.21%, success 100.0%, sample 10601)
4. AMD: 0.66% (p99 0.92%, success 100.0%, sample 10601)
5. MU: 0.87% (p99 1.02%, success 100.0%, sample 10601)
6. AAPL: 1.09% (p99 1.14%, success 100.0%, sample 10601)

**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: NVDAx posts the lowest price deviation at 0.057% (24h avg) on xStocks price accuracy, live onchain vs Nasdaq across 12 equities on Solana.

**Rankings (p50, 24h):**
1. NVDAx: 0.057% (p99 0.19%, success 100.0%, sample 10601)
2. TSLAx: 0.087% (p99 0.093%, success 95.9%, sample 10601)
3. COINx: 0.10% (p99 0.34%, success 96.2%, sample 10601)
4. AMZNx: 0.13% (p99 0.31%, success 95.9%, sample 10601)
5. PLTRx: 0.17% (p99 0.96%, success 100.0%, sample 10598)
6. HOODx: 0.21% (p99 0.33%, success 95.9%, sample 10601)
7. METAx: 0.27% (p99 0.52%, success 100.0%, sample 10601)
8. QQQx: 0.28% (p99 0.40%, success 95.9%, sample 10601)
9. GOOGLx: 0.29% (p99 0.35%, success 95.9%, sample 10601)
10. AAPLx: 0.48% (p99 0.59%, success 100.0%, sample 10601)
11. MSFTx: 0.60% (p99 0.88%, success 95.9%, sample 10601)
12. SPYx: 0.67% (p99 0.67%, success 95.9%, sample 10601)

**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: Orca (Solana) posts the lowest nav basis at 0.076% (24h avg) on USDY NAV basis, live market price vs official redemption rate.

**Rankings (p50, 24h):**
1. Orca (Solana): 0.076% (p99 0.086%, success 57.3%, sample 10599)
2. Pyth market composite: 0.21% (p99 0.61%, success 100.0%, sample 10599)

**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: PLTR posts the lowest weekend max drift at 0.52% (24h avg) on Tokenized stock weekend drift, how far each equity wanders Friday to Monday.

**Rankings (p50, 24h):**
1. PLTR: 0.52% (p99 0.67%, success 100.0%, sample 9363)
2. META: 0.55% (p99 0.73%, success 100.0%, sample 9363)
3. AAPL: 0.61% (p99 1.09%, success 100.0%, sample 9363)
4. NVDA: 1.12% (p99 1.12%, success 100.0%, sample 9363)
5. AMD: 1.53% (p99 1.53%, success 100.0%, sample 9363)
6. MU: 2.10% (p99 2.10%, success 100.0%, sample 9363)

**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 posts the lowest block push lag at 3 ms (p50, 24h) on Fastest Ethereum WebSocket newHeads push, live block-push lag across RPC providers.

**Rankings (p50, 24h):**
1. PublicNode: 3 ms (p99 10.24 s, success 99.3%, sample 28413.8)
2. dRPC: 108 ms (p99 10.24 s, success 100.0%, sample 28601.8)
3. Tenderly: 2.88 s (p99 10.24 s, success 97.8%, sample 28001.2)

**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 posts the lowest reliability incidents at 1 (24h) on Most reliable free public RPC, correctness incidents across 7 EVM chains.

**Rankings (p50, 24h):**
1. Lava: 1 (p99 122, success 99.4%, sample 166.092)
2. Arbitrum: 2 (p99 0, success 97.6%, sample 82.0449)
3. PublicNode: 61 (p99 57.0K, success 89.4%, sample 576.314)
4. Nodies: 167 (p99 0.250, success 66.2%, sample 494.274)
5. dRPC: 181 (p99 0.304, success 68.9%, sample 576.32)

**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 51.4% (24h avg) on Ethereum block builder market share.

**Rankings (p50, 24h):**
1. Titan: 51.4% (p99 51.4%, success 100.0%, sample 3693.28)
2. BuilderNet: 21.2% (p99 21.2%, success 100.0%, sample 1524.53)
3. Quasar: 14.6% (p99 14.6%, success 100.0%, sample 1050.36)
4. Vanilla: 7.62% (p99 7.62%, success 100.0%, sample 547.19)
5. Eureka: 2.91% (p99 2.91%, success 100.0%, sample 209.073)
6. Bob The Builder: 0.70% (p99 0.70%, success 100.0%, sample 50.0174)
7. beaverbuild: 0.52% (p99 0.52%, success 100.0%, sample 37.0128)
8. Other: 0.50% (p99 0.50%, success 100.0%, sample 36.0125)
9. Builder+: 0.39% (p99 0.39%, success 100.0%, sample 28.0097)

**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 posts the lowest rpc latency at 57 ms (p50, 24h) on Fastest free Polkadot RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. OnFinality: 57 ms (p99 2.15 s, success 100.0%, sample 4313.84)
2. PublicNode: 218 ms (p99 2.61 s, success 99.3%, sample 4314.84)
3. Parity: 305 ms (p99 5.07 s, success 97.9%, sample 4310.84)

**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 posts the lowest block push lag at 0.5 ms (p50, 24h) on Fastest Base WebSocket newHeads push, live block-push lag across RPC providers.

**Rankings (p50, 24h):**
1. PublicNode: 0.5 ms (p99 10.24 s, success 100.0%, sample 170758)
2. dRPC: 28 ms (p99 10.24 s, success 99.9%, sample 170758)

**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 posts the lowest 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 25 ms, success 76.8%, sample 670338)
2. PublicNode: 100 ms (p99 10.24 s, success 100.0%, sample 887472)

**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: live
- Headline: USDY leads yield deviation at 0.060% (24h avg) on Which tokenized T-bill or yield fund actually pays what it promises.

**Rankings (p50, 24h):**
1. USDY: 0.060% (p99 -3.55%, success 100.0%, sample 1121170000)

**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 249 (24h) on DEX indexer with most blockchains, live coverage ranking.

**Rankings (p50, 24h):**
1. GeckoTerminal: 249 (p99 249, success 100.0%, sample 249)
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: Osmosis Foundation posts the lowest rpc latency at 204 ms (p50, 24h) on Fastest free Osmosis RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Osmosis Foundation: 204 ms (p99 770 ms, success 100.0%, sample 4311.84)
2. PublicNode: 268 ms (p99 1.92 s, success 99.5%, sample 4309.87)
3. Polkachu: 277 ms (p99 2.38 s, success 98.4%, sample 4307.85)
4. LavenderFive: 327 ms (p99 1.60 s, success 98.5%, sample 4310.89)
5. Imperator: 578 ms (p99 2.63 s, success 59.3%, sample 4314.84)

**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 posts the lowest 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 145 ms, success 66.3%, sample 4315.84)
2. Hyperliquid Labs: 75 ms (p99 129 ms, success 91.7%, sample 4312.89)
3. Hypurrscan: 77 ms (p99 225 ms, success 100.0%, sample 4317.84)
4. Stakely: 437 ms (p99 1.19 s, success 99.9%, sample 4306.84)

**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 posts the lowest rpc latency at 14 ms (p50, 24h) on Fastest free TRON RPC, live no-key JSON-RPC endpoint latency.

**Rankings (p50, 24h):**
1. TronGrid: 14 ms (p99 108 ms, success 100.0%, sample 4322.84)
2. PublicNode: 163 ms (p99 2.02 s, success 98.4%, sample 4310.87)

**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 posts the lowest rpc latency at 69 ms (p50, 24h) on Fastest free Cosmos Hub RPC, live no-key Cosmos SDK endpoint latency.

**Rankings (p50, 24h):**
1. Lava Network: 69 ms (p99 1.08 s, success 100.0%, sample 4319.84)
2. Polkachu: 277 ms (p99 1.82 s, success 97.1%, sample 4314.84)
3. PublicNode: 279 ms (p99 2.78 s, success 98.8%, sample 4320.86)
4. LavenderFive: 327 ms (p99 1.66 s, success 98.3%, sample 4313.87)

**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: Injective Foundation posts the lowest rpc latency at 235 ms (p50, 24h) on Fastest free Injective RPC, live no-key Cosmos SDK endpoint latency.

**Rankings (p50, 24h):**
1. Injective Foundation: 235 ms (p99 605 ms, success 100.0%, sample 4311.84)
2. Polkachu: 275 ms (p99 2.00 s, success 98.6%, sample 4313.85)
3. LavenderFive: 325 ms (p99 1.54 s, success 98.4%, sample 4315.86)
4. PublicNode: 334 ms (p99 1.69 s, success 99.2%, sample 4316.86)

**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 posts the lowest rpc latency at 269 ms (p50, 24h) on Fastest free Neutron RPC, live no-key Cosmos SDK endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 269 ms (p99 1.28 s, success 99.0%, sample 4312.85)
2. PublicNode: 296 ms (p99 2.60 s, success 99.1%, sample 4313.86)
3. LavenderFive: 327 ms (p99 2.24 s, success 98.1%, sample 4309.85)

**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 posts the lowest 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 24 ms, success 100.0%, sample 4317.84)
2. Tenderly Gateway: 241 ms (p99 321 ms, success 100.0%, sample 4311.84)
3. dRPC: 356 ms (p99 1.75 s, success 88.1%, sample 4312.84)

**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 posts the lowest rpc latency at 76 ms (p50, 24h) on Fastest free Kaia RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Kaia Foundation: 76 ms (p99 135 ms, success 100.0%, sample 4317.84)

**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 posts the lowest 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 492 ms, success 100.0%, sample 4320.84)
2. Gelato: 199 ms (p99 718 ms, success 100.0%, sample 4311.84)
3. dRPC: 201 ms (p99 742 ms, success 89.9%, sample 4312.84)
4. Tenderly Gateway: 240 ms (p99 286 ms, success 100.0%, sample 4322.84)

**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 posts the lowest 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 283 ms, success 100.0%, sample 4321.84)
2. dRPC: 110 ms (p99 500 ms, success 90.6%, sample 4318.84)
3. PublicNode: 264 ms (p99 1.62 s, success 99.2%, sample 4314.86)

**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: Arbitrum posts the lowest vaa finalization at 1.50 s (p50, 24h) on Fastest Wormhole VAA finalization by source chain, live latency.

**Rankings (p50, 24h):**
1. Arbitrum: 1.50 s (p99 19.9 min, success 100.0%, sample 3.00105)
2. Sui: 3.28 s (p99 10.72 s, success 100.0%, sample 342.12)
3. Monad: 3.43 s (p99 7.50 s, success 100.0%, sample 50.0175)
4. Injective: 3.50 s (p99 4.97 s, success 100.0%, sample 1.00035)
5. BNB Chain: 4.38 s (p99 14.25 s, success 100.0%, sample 1226.43)
6. Polygon: 4.66 s (p99 14.28 s, success 100.0%, sample 906.317)
7. Ethereum: 5.00 s (p99 19.4 min, success 100.0%, sample 12.0042)
8. Avalanche: 5.09 s (p99 14.73 s, success 100.0%, sample 87.0305)
9. Berachain: 7.50 s (p99 9.95 s, success 100.0%, sample 1.00035)
10. Ink: 7.50 s (p99 9.95 s, success 100.0%, sample 15.0053)
11. Solana: 15.96 s (p99 24.38 s, success 100.0%, sample 14774.2)
12. Base: 40.00 s (p99 1.4 min, success 100.0%, sample 10.0035)

**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 98.7% (24h avg) on Best DEX aggregator for quoting newly-launched tokens.

**Rankings (p50, 24h):**
1. Jupiter: 98.7% (p99 98.7%, success 98.7%, sample 1376.48)
2. KyberSwap: 93.1% (p99 93.1%, success 93.1%, sample 901.313)
3. Mobula: 91.7% (p99 91.7%, success 91.7%, sample 2277.79)

**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 posts the lowest ccip delivery at 1.2 min (p50, 24h) on Fastest Chainlink CCIP source chain by end-to-end delivery latency.

**Rankings (p50, 24h):**
1. Solana: 1.2 min (p99 3.4 min, success 100.0%, sample 82.0287)
2. Monad: 1.6 min (p99 2.9 min, success 100.0%, sample 55.0191)
3. BNB Chain: 1.6 min (p99 4.9 min, success 100.0%, sample 196.069)
4. Avalanche: 1.7 min (p99 4.8 min, success 100.0%, sample 57.0198)
5. Berachain: 2.3 min (p99 3.0 min, success 100.0%, sample 3.00104)
6. Polygon: 13.3 min (p99 19.8 min, success 100.0%, sample 8.00278)
7. Ethereum: 17.2 min (p99 29.1 min, success 100.0%, sample 466.262)
8. Robinhood Chain: 17.8 min (p99 29.4 min, success 100.0%, sample 29.0101)
9. Optimism: 18.8 min (p99 29.7 min, success 100.0%, sample 3.00104)
10. Arbitrum: 19.2 min (p99 29.8 min, success 100.0%, sample 56.0199)
11. Base: 24.6 min (p99 45.8 min, success 100.0%, sample 170.059)
12. Ink: 25.0 min (p99 29.9 min, success 100.0%, sample 3.00104)
13. Linea: 55.0 min (p99 59.9 min, success 100.0%, sample 1.00035)

**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 posts the lowest layerzero delivery at 22.02 s (p50, 24h) on Fastest LayerZero source chain by end-to-end message delivery.

**Rankings (p50, 24h):**
1. Monad: 22.02 s (p99 19.4 min, success 100.0%, sample 218.076)
2. Arbitrum: 26.36 s (p99 27.8 min, success 100.0%, sample 2340.82)
3. BNB Chain: 28.32 s (p99 4.0 min, success 100.0%, sample 2372.84)
4. Celo: 42.86 s (p99 1.9 min, success 100.0%, sample 24.0084)
5. Avalanche: 47.98 s (p99 9.7 min, success 100.0%, sample 327.114)
6. Robinhood Chain: 49.68 s (p99 5.0 min, success 100.0%, sample 615.215)
7. Solana: 51.67 s (p99 4.5 min, success 100.0%, sample 880.306)
8. Unichain: 57.71 s (p99 29.4 min, success 100.0%, sample 117.041)
9. Base: 1.1 min (p99 4.9 min, success 100.0%, sample 2331.82)
10. Optimism: 1.1 min (p99 3.4 min, success 100.0%, sample 1118.39)
11. Ink: 1.4 min (p99 4.9 min, success 100.0%, sample 35.0123)
12. Mantle: 1.4 min (p99 14.1 min, success 100.0%, sample 57.02)
13. Polygon: 1.8 min (p99 18.3 min, success 100.0%, sample 447.157)
14. Scroll: 1.8 min (p99 8.8 min, success 100.0%, sample 70.0245)
15. Linea: 2.5 min (p99 7.8 min, success 100.0%, sample 89.0313)
16. Ethereum: 4.1 min (p99 19.4 min, success 100.0%, sample 2262.79)

**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 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: BNB Chain posts the lowest axelar gmp delivery at 39.52 s (p50, 24h) on Fastest Axelar GMP source chain by end-to-end delivery.

**Rankings (p50, 24h):**
1. BNB Chain: 39.52 s (p99 2.4 min, success 100.0%, sample 117.041)
2. Avalanche: 41.79 s (p99 2.0 min, success 100.0%, sample 35.0135)
3. Polygon: 42.81 s (p99 1.9 min, success 100.0%, sample 128.044)
4. Osmosis: 49.17 s (p99 6.1 min, success 100.0%, sample 157.055)
5. Ethereum: 17.1 min (p99 21.6 min, success 100.0%, sample 168.06)
6. Arbitrum: 20.7 min (p99 29.8 min, success 100.0%, sample 54.0188)
7. Celo: 25.0 min (p99 29.9 min, success 100.0%, sample 2.00069)
8. Optimism: 25.0 min (p99 29.9 min, success 100.0%, sample 57.0198)
9. Base: 25.2 min (p99 37.3 min, success 100.0%, sample 82.0285)

**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 posts the lowest rpc latency at 118 ms (p50, 24h) on Fastest free Sei RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Sei Labs: 118 ms (p99 1.87 s, success 98.8%, sample 4315.84)
2. Stakeme: 376 ms (p99 3.20 s, success 98.0%, sample 4313.84)

**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 posts the lowest rpc latency at 192 ms (p50, 24h) on Fastest free Mode RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Mode Labs: 192 ms (p99 2.06 s, success 99.0%, sample 4316.85)
2. dRPC: 521 ms (p99 1.42 s, success 83.8%, sample 4317.84)

**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 posts the lowest rpc latency at 248 ms (p50, 24h) on Fastest free Ronin RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Sky Mavis: 248 ms (p99 2.37 s, success 98.8%, sample 4309.85)
2. Tenderly Gateway: 329 ms (p99 361 ms, success 100.0%, sample 4312.84)

**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 posts the lowest rpc latency at 225 ms (p50, 24h) on Fastest free Immutable zkEVM RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Immutable: 225 ms (p99 250 ms, success 100.0%, sample 4322.84)
2. Tenderly Gateway: 328 ms (p99 436 ms, success 100.0%, sample 4313.84)
3. dRPC: 347 ms (p99 643 ms, success 89.9%, sample 4322.84)

**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 posts the lowest ws connect to snapshot at 2.21 s (p50, 24h) on Polymarket WebSocket latency, live connection and update speed from 3 regions.

**Rankings (p50, 24h):**
1. Polymarket: 2.21 s (p99 3.95 s, success 50.0%, sample 17.0067)
2. Kalshi: 1.0 min (p99 5.0 min, success 50.0%, sample 4.00172)

**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 1364740000)
2. HyperStake: 2.24% (p99 2.24%, success 100.0%, sample 736771000)
3. CMI: 2.24% (p99 2.24%, success 100.0%, sample 679529000)
4. Flowdex: 2.24% (p99 2.24%, success 100.0%, sample 337612000)
5. Hypurrscanning: 2.22% (p99 2.22%, success 100.0%, sample 1755610000)
6. Alphaticks: 2.22% (p99 2.22%, success 100.0%, sample 380312000)
7. Purrposeful x HyBridge x PiP: 2.20% (p99 2.20%, success 100.0%, sample 538370000)
8. Hyperliquid Strategies x Unit: 2.20% (p99 2.20%, success 100.0%, sample 1706830000)
9. Nansen x HypurrCollective: 2.20% (p99 2.20%, success 100.0%, sample 1637800000)
10. Hyperbeat x P2P x Hypio: 2.20% (p99 2.20%, success 100.0%, sample 291585000)
11. Hyper Foundation 3: 2.18% (p99 2.18%, success 100.0%, sample 4216460000)
12. Hyper Foundation 2: 2.18% (p99 2.18%, success 100.0%, sample 4077020000)
13. Hyper Foundation 1: 2.18% (p99 2.18%, success 100.0%, sample 3964970000)
14. Hyper Foundation 4: 2.18% (p99 2.18%, success 100.0%, sample 2603260000)
15. Hyper Foundation 5: 2.18% (p99 2.18%, success 100.0%, sample 1150430000)
16. Hyperdash: 2.18% (p99 2.18%, success 100.0%, sample 731811000)
17. HypurrCorea - Spacebar x DeSpread: 2.18% (p99 2.18%, success 100.0%, sample 622218000)
18. USDT0 x Luganodes: 2.18% (p99 2.18%, success 100.0%, sample 641532000)
19. Bitwise Onchain Solutions x FalconX: 2.18% (p99 2.18%, success 100.0%, sample 318406000)
20. Liquid Spirit x Hydromancer x Rekt Gang: 2.18% (p99 2.18%, success 100.0%, sample 342568000)
21. Enigma - Hypedexer.com X Meria: 2.18% (p99 2.18%, success 100.0%, sample 253142000)
22. Kinetiq x Hyperion: 2.15% (p99 2.15%, success 100.0%, sample 515973000)
23. ValiDAO: 2.15% (p99 2.15%, success 100.0%, sample 494036000)
24. ASXN: 2.13% (p99 2.13%, success 100.0%, sample 658197000)
25. B-Harvest: 2.13% (p99 2.13%, success 100.0%, sample 390544000)
26. Anchorage By Figment: 2.02% (p99 2.02%, success 100.0%, sample 2270050000)
27. Asymmetric Research: 0.83% (p99 0.83%, success 54.1%, sample 169389000)

**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 546 (24h) on Most tradable markets on a perp DEX, live count across 14 venues.

**Rankings (p50, 24h):**
1. Aster: 546 (p99 546, success 85.7%, sample 2880)
2. gains.trade: 360 (p99 360, success 83.3%, sample 2880)
3. edgeX: 292 (p99 292, success 56.8%, sample 2880)
4. Extended: 286 (p99 287, success 84.7%, sample 2880)
5. Aevo: 229 (p99 229, success 71.3%, sample 2880)
6. Lighter: 212 (p99 212, success 85.7%, sample 2880)
7. GRVT: 185 (p99 185, success 71.4%, sample 2880)
8. Hyperliquid: 177 (p99 177, success 85.7%, sample 2880)
9. dYdX v4: 99 (p99 99, success 85.7%, sample 2880)
10. Ostium: 75 (p99 75, success 83.3%, sample 2880)
11. Pacifica: 75 (p99 75, success 85.7%, sample 2880)
12. Vertex: 68 (p99 68, success 85.7%, sample 2880)
13. Paradex: 62 (p99 62, success 85.7%, sample 2880)
14. Polymarket: 52 (p99 52, success 79.9%, sample 2880)

**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 posts the lowest 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 2880)
2. GMX v2: 1.000x (p99 1.000x, success 99.7%, sample 2880)
3. Hyperliquid: 1.157x (p99 1.015x, success 100.0%, sample 2840)
4. Extended: 1.203x (p99 1.007x, success 97.9%, sample 2880)
5. Aster: 1.300x (p99 1.016x, success 100.0%, sample 2880)
6. dYdX v4: 1.607x (p99 1.053x, success 100.0%, sample 2880)
7. Lighter: 9.27x (p99 1.545x, success 100.0%, sample 2850)

**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 posts the lowest mark price deviation at 0.022% (24h avg) on Perp DEX mark price fidelity: deviation from CEX spot reference, live.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.022% (p99 0.11%, success 100.0%, sample 2880)
2. Lighter: 0.032% (p99 0.078%, success 100.0%, sample 2880)
3. Paradex: 0.035% (p99 0.16%, success 100.0%, sample 2880)
4. dYdX v4: 0.036% (p99 0.11%, success 100.0%, sample 2880)
5. gains.trade: 0.037% (p99 0.10%, success 100.0%, sample 2880)
6. GMX v2: 0.037% (p99 0.10%, success 100.0%, sample 2880)

**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,725 (24h) on Perp DEX security track record: days without a recorded exploit, live.

**Rankings (p50, 24h):**
1. gains.trade: 1,725 (p99 1,725, success 100.0%, sample 2880)
2. Lighter: 1,148 (p99 1,148, success 100.0%, sample 2880)
3. dYdX v4: 1,056 (p99 1,056, success 100.0%, sample 2880)
4. Paradex: 1,056 (p99 1,056, success 100.0%, sample 2880)
5. Hyperliquid: 1,025 (p99 1,025, success 100.0%, sample 2880)
6. GMX v2: 409 (p99 409, success 100.0%, sample 2880)

**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 posts the lowest rpc latency at 26 ms (p50, 24h) on Fastest free Kava RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 26 ms (p99 400 ms, success 100.0%, sample 4315.84)
2. PublicNode: 110 ms (p99 1.67 s, success 99.2%, sample 4310.86)
3. Kava Labs: 239 ms (p99 989 ms, success 100.0%, sample 4318.84)
4. dRPC: 245 ms (p99 519 ms, success 90.9%, sample 4313.84)

**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 posts the lowest rpc latency at 192 ms (p50, 24h) on Fastest free Zora RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Zora Network: 192 ms (p99 1.79 s, success 99.4%, sample 4313.86)
2. Conduit: 192 ms (p99 1.58 s, success 99.8%, sample 4312.84)
3. dRPC: 318 ms (p99 657 ms, success 89.4%, sample 4317.84)

**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 posts the lowest rpc latency at 324 ms (p50, 24h) on Fastest free Abstract RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Abstract Foundation: 324 ms (p99 1.28 s, success 100.0%, sample 4317.84)
2. dRPC: 341 ms (p99 1.21 s, success 59.2%, sample 4317.84)

**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 posts the lowest rpc latency at 202 ms (p50, 24h) on Fastest free ApeChain RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. ApeChain: 202 ms (p99 1.77 s, success 99.2%, sample 4308.85)
2. dRPC: 301 ms (p99 840 ms, success 88.2%, sample 4317.84)
3. Tenderly: 328 ms (p99 526 ms, success 100.0%, sample 4315.84)

**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 posts the lowest rpc latency at 16 ms (p50, 24h) on Fastest free Lisk RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 16 ms (p99 156 ms, success 96.8%, sample 4317.84)
2. Lisk: 326 ms (p99 1.32 s, success 100.0%, sample 4316.84)
3. Tenderly: 329 ms (p99 366 ms, success 99.8%, sample 4317.84)

**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 posts the lowest rpc latency at 18 ms (p50, 24h) on Fastest free Swellchain RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 18 ms (p99 354 ms, success 70.9%, sample 4308.59)
2. dRPC: 174 ms (p99 515 ms, success 85.6%, sample 4308.84)

**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 posts the lowest rpc latency at 171 ms (p50, 24h) on Fastest free Cyber RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Cyber Network: 171 ms (p99 186 ms, success 100.0%, sample 4321.84)
2. AltLayer: 188 ms (p99 2.26 s, success 99.1%, sample 4318.91)

**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 posts the lowest rpc latency at 194 ms (p50, 24h) on Fastest free Rootstock RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Rootstock Foundation: 194 ms (p99 871 ms, success 99.9%, sample 4321.84)
2. dRPC: 346 ms (p99 1.53 s, success 79.7%, sample 4316.84)

**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 posts the lowest rpc latency at 164 ms (p50, 24h) on Fastest free Metis RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 164 ms (p99 2.15 s, success 99.1%, sample 4316.86)
2. dRPC: 233 ms (p99 285 ms, success 90.5%, sample 4313.84)
3. Metis: 277 ms (p99 3.98 s, success 98.2%, sample 4309.85)

**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 posts the lowest rpc latency at 209 ms (p50, 24h) on Fastest free Manta Pacific RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Manta Network: 209 ms (p99 1.77 s, success 99.3%, sample 4304.86)
2. dRPC: 213 ms (p99 1.51 s, success 89.7%, sample 4322.84)

**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: Story Foundation posts the lowest rpc latency at 79 ms (p50, 24h) on Fastest free Story RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Story Foundation: 79 ms (p99 111 ms, success 100.0%, sample 4313.84)
2. Ankr: 82 ms (p99 319 ms, success 100.0%, sample 4322.84)
3. Stakely: 277 ms (p99 1.09 s, success 99.1%, sample 4308.84)
4. PublicNode: 520 ms (p99 2.35 s, success 99.3%, sample 4312.85)

**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 posts the lowest rpc latency at 94 ms (p50, 24h) on Fastest free Morph RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Morph: 94 ms (p99 141 ms, success 100.0%, sample 4315.84)
2. QuickNode: 163 ms (p99 204 ms, success 100.0%, sample 4318.84)
3. dRPC: 255 ms (p99 359 ms, success 89.8%, sample 4316.84)

**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 posts the lowest rpc latency at 64 ms (p50, 24h) on Fastest free Moonriver RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. OnFinality: 64 ms (p99 2.14 s, success 100.0%, sample 4319.75)

**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 posts the lowest 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 500 ms, success 90.6%, sample 4313.84)
2. Hemi Labs: 231 ms (p99 372 ms, success 100.0%, sample 4318.84)

**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 posts the lowest rpc latency at 188 ms (p50, 24h) on Fastest free BOB RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. BOB: 188 ms (p99 2.03 s, success 99.3%, sample 4309.85)
2. dRPC: 317 ms (p99 735 ms, success 90.2%, sample 4312.84)
3. Tenderly: 327 ms (p99 370 ms, success 100.0%, sample 4317.84)

**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 posts the lowest rpc latency at 299 ms (p50, 24h) on Fastest free Polygon zkEVM RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Polygon zkEVM: 299 ms (p99 327 ms, success 100.0%, sample 4317.84)
2. dRPC: 315 ms (p99 517 ms, success 90.2%, sample 4313.84)

**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 posts the lowest rpc latency at 172 ms (p50, 24h) on Fastest free Arbitrum Nova RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 172 ms (p99 1.89 s, success 99.2%, sample 4316.84)
2. dRPC: 215 ms (p99 684 ms, success 88.8%, sample 4317.84)

**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 posts the lowest rpc latency at 43 ms (p50, 24h) on Fastest free X Layer RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. X Layer: 43 ms (p99 100 ms, success 100.0%, sample 4317.84)
2. dRPC: 167 ms (p99 571 ms, success 90.8%, sample 4322.84)

**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 posts the lowest rpc latency at 154 ms (p50, 24h) on Fastest free Flare RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 154 ms (p99 412 ms, success 100.0%, sample 4317.84)
2. dRPC: 234 ms (p99 290 ms, success 90.7%, sample 4322.84)
3. Flare Foundation: 307 ms (p99 1.25 s, success 99.8%, sample 4311.84)

**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 posts the lowest rpc latency at 17 ms (p50, 24h) on Fastest free Core Chain RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 17 ms (p99 41 ms, success 100.0%, sample 4315.84)
2. dRPC: 170 ms (p99 462 ms, success 89.9%, sample 4317.84)
3. Core DAO: 258 ms (p99 1.62 s, success 99.8%, sample 4315.85)

**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: Fuse Foundation posts the lowest rpc latency at 190 ms (p50, 24h) on Fastest free Fuse Network RPC, live no-key EVM endpoint latency.

**Rankings (p50, 24h):**
1. Fuse Foundation: 190 ms (p99 283 ms, success 100.0%, sample 4317.84)
2. dRPC: 191 ms (p99 517 ms, success 89.9%, sample 4312.84)

**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 34 (24h) on Perp DEX capital efficiency: active markets per $M TVL, live.

**Rankings (p50, 24h):**
1. gains.trade: 34 (p99 34, success 83.3%, sample 2880)
2. Ostium: 4 (p99 4, success 83.3%, sample 2880)
3. dYdX v4: 0.874 (p99 0.874, success 85.7%, sample 2880)
4. Hyperliquid: 0.027 (p99 0.027, success 85.7%, sample 2880)

**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 posts the lowest rpc latency at 18 ms (p50, 24h) on Fastest free Filecoin RPC, live no-key FEVM endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 18 ms (p99 42 ms, success 100.0%, sample 4318.84)
2. Glif: 249 ms (p99 759 ms, success 100.0%, sample 4321.84)
3. dRPC: 294 ms (p99 687 ms, success 90.2%, sample 4312.84)

**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 posts the lowest rpc latency at 189 ms (p50, 24h) on Fastest free Canto RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Canto Official: 189 ms (p99 547 ms, success 100.0%, sample 4317.84)

**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 posts the lowest rpc latency at 194 ms (p50, 24h) on Fastest free Aurora RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Aurora Labs: 194 ms (p99 612 ms, success 100.0%, sample 4314.84)

**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: Bitlayer Official posts the lowest rpc latency at 14 ms (p50, 24h) on Fastest free Bitlayer RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Bitlayer Official: 14 ms (p99 32 ms, success 100.0%, sample 4317.84)
2. Ankr: 17 ms (p99 88 ms, success 100.0%, sample 4318.84)
3. dRPC: 289 ms (p99 544 ms, success 90.3%, sample 4321.84)

**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 posts the lowest rpc latency at 340 ms (p50, 24h) on Fastest free B² Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 340 ms (p99 668 ms, success 90.1%, sample 4317.84)
2. B² Network Official: 456 ms (p99 579 ms, success 100.0%, sample 4312.84)

**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: Polkachu posts the lowest rpc latency at 257 ms (p50, 24h) on Fastest free dYdX Chain RPC, live no-key Cosmos SDK endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 257 ms (p99 1.78 s, success 99.4%, sample 4318.84)
2. PublicNode: 270 ms (p99 1.80 s, success 99.4%, sample 4308.86)
3. LavenderFive: 327 ms (p99 1.51 s, success 98.1%, sample 4310.87)

**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 posts the lowest rpc latency at 276 ms (p50, 24h) on Fastest free Celestia RPC, live no-key Cosmos SDK endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 276 ms (p99 1.63 s, success 97.1%, sample 4308.84)
2. LavenderFive: 329 ms (p99 1.61 s, success 98.4%, sample 4315.87)
3. PublicNode: 590 ms (p99 2.36 s, success 98.9%, sample 4315.85)

**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 posts the lowest rpc latency at 255 ms (p50, 24h) on Fastest free Boba Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Boba Foundation: 255 ms (p99 972 ms, success 99.8%, sample 4308.84)
2. dRPC: 285 ms (p99 511 ms, success 90.2%, sample 4317.84)

**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 posts the lowest rpc latency at 18 ms (p50, 24h) on Fastest free XDC Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 18 ms (p99 41 ms, success 100.0%, sample 4318.84)
2. XDC eRPC: 286 ms (p99 2.32 s, success 99.8%, sample 4308.86)

**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 posts the lowest rpc latency at 60 ms (p50, 24h) on Fastest free Astar Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. OnFinality: 60 ms (p99 2.22 s, success 100.0%, sample 4311.84)

**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 posts the lowest rpc latency at 273 ms (p50, 24h) on Fastest free Oasis Sapphire RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Oasis Foundation: 273 ms (p99 2.56 s, success 99.0%, sample 4315.84)

**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 posts the lowest rpc latency at 280 ms (p50, 24h) on Fastest free Oasis Emerald RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Oasis Foundation: 280 ms (p99 3.29 s, 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.
- 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 posts the lowest rpc latency at 151 ms (p50, 24h) on Fastest free Conflux eSpace RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Conflux Foundation: 151 ms (p99 449 ms, success 100.0%, sample 4315.84)
2. Conflux Global: 259 ms (p99 2.39 s, success 99.5%, sample 4309.85)

**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 posts the lowest rpc latency at 256 ms (p50, 24h) on Fastest free IoTeX RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. IoTeX Mirror: 256 ms (p99 2.44 s, success 99.1%, sample 4321.86)

**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 posts the lowest rpc latency at 168 ms (p50, 24h) on Fastest free Harmony ONE RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Harmony S0: 168 ms (p99 506 ms, success 91.7%, sample 4318.87)

**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 posts the lowest rpc latency at 190 ms (p50, 24h) on Fastest free Zircuit RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Zircuit Foundation: 190 ms (p99 1.42 s, success 99.3%, sample 4312.85)

**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 posts the lowest rpc latency at 314 ms (p50, 24h) on Fastest free Plume Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 314 ms (p99 623 ms, success 89.0%, sample 4317.84)

**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 posts the lowest rpc latency at 162 ms (p50, 24h) on Fastest free Vana RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Vana Foundation: 162 ms (p99 205 ms, success 100.0%, sample 4312.84)

**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 posts the lowest rpc latency at 17 ms (p50, 24h) on Fastest free Gravity Alpha RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Ankr: 17 ms (p99 43 ms, success 100.0%, sample 4316.84)
2. Gravity Foundation: 194 ms (p99 1.83 s, success 99.1%, sample 4311.85)

**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 posts the lowest rpc latency at 406 ms (p50, 24h) on Fastest free Reya Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Reya Foundation: 406 ms (p99 1.96 s, success 99.4%, sample 4307.85)

**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 posts the lowest rpc latency at 276 ms (p50, 24h) on Fastest free Akash Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 276 ms (p99 2.13 s, success 96.6%, sample 4306.84)
2. Ecostake: 313 ms (p99 2.26 s, success 99.1%, sample 4307.85)
3. PublicNode: 485 ms (p99 1.39 s, success 99.5%, sample 4315.96)

**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 posts the lowest rpc latency at 277 ms (p50, 24h) on Fastest free Stride RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 277 ms (p99 1.91 s, success 98.7%, sample 4308.85)
2. LavenderFive: 330 ms (p99 1.59 s, success 98.4%, sample 4319.86)

**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 posts the lowest rpc latency at 276 ms (p50, 24h) on Fastest free Juno RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 276 ms (p99 2.30 s, success 96.8%, sample 4309.85)
2. PublicNode: 281 ms (p99 2.38 s, success 99.2%, sample 4315.86)

**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 posts the lowest rpc latency at 274 ms (p50, 24h) on Fastest free Axelar RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 274 ms (p99 2.27 s, success 98.5%, sample 4309.85)
2. PublicNode: 282 ms (p99 1.60 s, success 99.4%, sample 4308.85)
3. LavenderFive: 326 ms (p99 1.70 s, success 98.2%, sample 4312.87)

**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 posts the lowest rpc latency at 275 ms (p50, 24h) on Fastest free Dymension RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 275 ms (p99 2.07 s, success 98.5%, sample 4314.84)
2. LavenderFive: 325 ms (p99 1.99 s, success 98.1%, sample 4310.87)

**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: Polkachu posts the lowest rpc latency at 275 ms (p50, 24h) on Fastest free Persistence RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 275 ms (p99 1.97 s, success 98.9%, sample 4307.84)
2. Persistence Foundation: 296 ms (p99 2.22 s, success 99.2%, sample 4313.85)

**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: PublicNode posts the lowest rpc latency at 271 ms (p50, 24h) on Fastest free Coreum RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 271 ms (p99 1.91 s, success 99.3%, sample 4314.85)
2. Polkachu: 276 ms (p99 1.98 s, success 98.7%, sample 4315.85)
3. Coreum Foundation: 590 ms (p99 950 ms, success 78.7%, sample 4313.04)

**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 posts the lowest rpc latency at 274 ms (p50, 24h) on Fastest free Nolus RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 274 ms (p99 1.89 s, 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":"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 posts the lowest rpc latency at 275 ms (p50, 24h) on Fastest free Archway RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 275 ms (p99 2.48 s, success 98.2%, sample 4314.85)
2. LavenderFive: 346 ms (p99 1.61 s, success 98.2%, sample 4315.86)

**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 posts the lowest rpc latency at 205 ms (p50, 24h) on Fastest free Nibiru RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Nibiru Foundation: 205 ms (p99 634 ms, success 88.7%, sample 4311.95)
2. Polkachu: 279 ms (p99 3.04 s, success 97.0%, sample 4313.84)

**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 posts the lowest rpc latency at 277 ms (p50, 24h) on Fastest free Quicksilver RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 277 ms (p99 2.15 s, success 97.1%, sample 4316.84)
2. Quicksilver Foundation: 314 ms (p99 368 ms, success 100.0%, sample 4317.84)

**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: Polkachu posts the lowest rpc latency at 274 ms (p50, 24h) on Fastest free Terra RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 274 ms (p99 1.98 s, success 98.6%, sample 4314.85)
2. LavenderFive: 306 ms (p99 1.99 s, success 98.2%, sample 4313.86)
3. PublicNode: 598 ms (p99 2.20 s, success 99.0%, sample 4313.86)

**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 posts the lowest rpc latency at 286 ms (p50, 24h) on Fastest free Regen Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Polkachu: 286 ms (p99 2.31 s, success 98.5%, sample 4308.85)

**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 posts the lowest rpc latency at 244 ms (p50, 24h) on Fastest free Comdex RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. STAVR: 244 ms (p99 437 ms, success 100.0%, sample 4315.84)

**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 posts the lowest rpc latency at 242 ms (p50, 24h) on Fastest free Fantom RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Fantom Foundation: 242 ms (p99 289 ms, success 100.0%, sample 4316.84)
2. dRPC: 253 ms (p99 355 ms, success 90.6%, sample 4313.84)

**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 posts the lowest rpc latency at 56 ms (p50, 24h) on Fastest free Kusama RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. OnFinality: 56 ms (p99 2.36 s, success 100.0%, sample 4316.84)
2. PublicNode: 220 ms (p99 1.88 s, success 99.2%, sample 4315.85)
3. dRPC: 789 ms (p99 1.05 s, success 90.3%, sample 4319.84)

**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 Hydration RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/hydration-rpc
- JSON: https://openchainbench.com/api/stat/hydration-rpc
- Status: live
- Headline: Hydration posts the lowest rpc latency at 14 ms (p50, 24h) on Fastest free Hydration RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Hydration: 14 ms (p99 100 ms, success 100.0%, sample 4311.84)
2. Dwellir: 323 ms (p99 660 ms, success 100.0%, sample 4315.84)

**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. Substrate JSON-RPC.
- 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 (block more than 40 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=hydration. Provider coverage at launch: 2 endpoints (Hydration official, Dwellir).

## 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 posts the lowest rpc latency at 684 ms (p50, 24h) on Fastest free ZetaChain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Thirdweb: 684 ms (p99 1.16 s, success 0.2%, sample 4306.85)

**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 posts the lowest rpc latency at 113 ms (p50, 24h) on Fastest free HAQQ Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 113 ms (p99 1.94 s, success 99.1%, sample 4313.87)
2. dRPC: 249 ms (p99 825 ms, success 89.4%, sample 4313.84)
3. HAQQ Foundation: 287 ms (p99 3.07 s, success 99.1%, sample 4312.84)

**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 posts the lowest 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 70 ms, success 100.0%, sample 4316.84)
2. dRPC: 208 ms (p99 869 ms, success 88.2%, sample 4317.84)

**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 posts the lowest rpc latency at 124 ms (p50, 24h) on Fastest free Chiliz Chain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 124 ms (p99 2.42 s, success 99.1%, sample 4314.85)
2. Ankr: 187 ms (p99 303 ms, success 100.0%, sample 4322.84)
3. Chiliz Foundation: 240 ms (p99 1.91 s, success 99.0%, sample 4309.85)

**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: WeMade posts the lowest rpc latency at 69 ms (p50, 24h) on Fastest free WEMIX RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. WeMade: 69 ms (p99 162 ms, success 58.5%, sample 4320.27)
2. dRPC: 169 ms (p99 484 ms, success 90.2%, sample 4317.84)

**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 posts the lowest rpc latency at 309 ms (p50, 24h) on Fastest free Songbird RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Flare Foundation: 309 ms (p99 1.25 s, success 99.8%, sample 4319.84)

**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) posts the lowest rpc latency at 235 ms (p50, 24h) on Fastest free Cronos zkEVM RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Cronos (Crypto.com): 235 ms (p99 839 ms, success 100.0%, sample 4317.84)
2. dRPC: 287 ms (p99 685 ms, success 88.1%, sample 4313.84)

**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: 2 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 posts the lowest rpc latency at 250 ms (p50, 24h) on Fastest free Ethereum Classic RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 250 ms (p99 427 ms, success 90.3%, sample 4313.84)

**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 posts the lowest rpc latency at 239 ms (p50, 24h) on Fastest free Telos EVM RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 239 ms (p99 697 ms, success 89.6%, sample 4312.84)

**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 posts the lowest rpc latency at 106 ms (p50, 24h) on Fastest free PulseChain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. PublicNode: 106 ms (p99 1.67 s, success 99.8%, sample 4314.84)
2. PulseChain Foundation: 255 ms (p99 621 ms, success 100.0%, sample 4317.84)
3. G4MM4: 266 ms (p99 1.95 s, success 98.7%, sample 4307.86)

**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 posts the lowest rpc latency at 255 ms (p50, 24h) on Fastest free Warden Protocol RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Warden Foundation: 255 ms (p99 2.06 s, success 99.4%, sample 4312.85)
2. PublicNode: 594 ms (p99 2.13 s, success 99.2%, sample 4310.85)

**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 posts the lowest rpc latency at 279 ms (p50, 24h) on Fastest free Oraichain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Orai Foundation: 279 ms (p99 1.86 s, success 98.7%, sample 4315.84)
2. PublicNode: 326 ms (p99 2.31 s, success 99.4%, sample 4315.84)

**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 posts the lowest rpc latency at 54 ms (p50, 24h) on Fastest free Peaq Network RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. OnFinality: 54 ms (p99 2.31 s, success 100.0%, sample 4313.84)
2. PublicNode: 209 ms (p99 2.11 s, success 99.3%, sample 4310.86)

**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 $146.72M (24h) on Solana meme launchpad leaderboard: PumpFun vs Flap vs Bankr, live 24h volume.

**Rankings (p50, 24h):**
1. PumpFun: $146.72M (p99 $146.72M, success 100.0%, sample 3653050)
2. Flap: $31.01M (p99 $31.01M, success 100.0%, sample 558141)
3. Meteora DBC: $8.70M (p99 $8.70M, success 100.0%, sample 622108)
4. NOXA Fun: $7.80M (p99 $7.80M, success 100.0%, sample 32933)
5. Bankr: $2.76M (p99 $2.76M, success 100.0%, sample 18319)
6. LetsCash: $566.9K (p99 $566.9K, success 100.0%, sample 11196)
7. Raydium Launchlab: $246.1K (p99 $246.1K, success 100.0%, sample 5184)
8. dontblink: $89.0K (p99 $89.0K, success 100.0%, sample 958)

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

## Trading platform leaderboard: GMGN vs Axiom vs Fomo vs pump.fun, 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 $124.30M (24h) on Trading platform leaderboard: GMGN vs Axiom vs Fomo vs pump.fun, live 24h volume.

**Rankings (p50, 24h):**
1. GMGN: $124.30M (p99 $124.30M, success 100.0%, sample 124296000)
2. Axiom: $65.28M (p99 $65.28M, success 100.0%, sample 65275500)
3. Fomo: $19.43M (p99 $19.43M, success 100.0%, sample 19430500)
4. BasedBot: $14.26M (p99 $14.26M, success 100.0%, sample 14263900)
5. pump.fun: $13.42M (p99 $13.42M, success 100.0%, sample 13422300)
6. Terminal: $10.27M (p99 $10.27M, success 100.0%, sample 10265000)
7. Trojan: $2.70M (p99 $2.70M, success 100.0%, sample 2701080)
8. Photon: $1.41M (p99 $1.41M, success 100.0%, sample 1409300)

**Methodology**:
- Source: Dune community datasets (dataset_*_daily). Each dataset covers one trading platform across all blockchains it operates on.
- Poll cadence: harness queries Dune every 4 hours and updates Prometheus gauges. Prometheus scrapes :2112/metrics every 60 seconds.
- Volume: sum of volume_usd across all blockchains for the most recent complete day in each platform's dataset. Higher = more total user activity.
- pump.fun: dataset_pumpapp_sol_daily (Solana bonding-curve) + dataset_pumpfun_relay_daily filtered to req_class='swap'. pump.fun cut fees to 0% in Aug 2026; volume is for their own frontend only (pumpapp), not all bonding-curve activity.
- fomo: dataset_fomo_sol_daily (Solana only).
- BasedBot: multi-chain bot (Robinhood node, BNB, Base, Solana, ETH, HyperEVM, Avalanche).

## Crypto trading app iOS App Store ratings, 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.79x (p50, 24h) on Crypto trading app iOS App Store ratings, live.

**Rankings (p50, 24h):**
1. Fomo: 4.79x (p99 4.79x, success 100.0%, sample 9815)
2. Kraken: 4.74x (p99 4.74x, success 100.0%, sample 33998)
3. PumpFun: 4.70x (p99 4.70x, success 100.0%, sample 2460)
4. Bybit: 4.69x (p99 4.69x, success 100.0%, sample 46904)
5. Coinbase: 4.68x (p99 4.68x, success 100.0%, sample 1796550)
6. Crypto.com: 4.66x (p99 4.66x, success 100.0%, sample 332739)
7. Robinhood: 4.29x (p99 4.29x, success 100.0%, sample 4805600)
8. Invo: 4.27x (p99 4.27x, success 100.0%, sample 428)
9. Moonshot: 4.22x (p99 4.22x, success 100.0%, sample 28591)
10. Binance.US: 4.21x (p99 4.21x, success 100.0%, sample 111021)
11. GMGN: 3.74x (p99 3.74x, success 100.0%, sample 84)

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

## Solana memecoin platform fee rates: Axiom vs Fomo vs pump.fun vs GMGN vs Trojan, live 24h

- Category: Trading
- Metric: 24h take rate (pct)
- Page: https://openchainbench.com/benchmarks/memecoin-platforms
- JSON: https://openchainbench.com/api/stat/memecoin-platforms
- Status: live
- Headline: BasedBot posts the lowest 24h take rate at 0.57% (24h avg) on Solana memecoin platform fee rates: Axiom vs Fomo vs pump.fun vs GMGN vs Trojan, live 24h.

**Rankings (p50, 24h):**
1. BasedBot: 0.57% (p99 0.57%, success 100.0%, sample 80877.1)
2. GMGN: 0.80% (p99 0.80%, success 100.0%, sample 994990)
3. Trojan: 0.91% (p99 0.91%, success 100.0%, sample 24701.6)
4. Photon: 0.94% (p99 0.94%, success 100.0%, sample 13296.5)
5. Terminal: 1.00% (p99 1.00%, success 100.0%, sample 102249)
6. Axiom: 1.28% (p99 1.28%, success 100.0%, sample 836357)
7. Fomo: 1.32% (p99 1.32%, success 100.0%, sample 255672)
8. Maestro: 2.00% (p99 2.00%, success 100.0%, sample 11522.1)

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

## 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 $124.30M (24h) on Solana DEX volume: pump.fun vs Axiom vs GMGN vs Fomo, live 24h.

**Rankings (p50, 24h):**
1. GMGN: $124.30M (p99 $124.30M, success 100.0%, sample n/a)
2. pump.fun: $97.78M (p99 $97.78M, success 100.0%, sample n/a)
3. Axiom: $75.34M (p99 $75.34M, success 100.0%, sample n/a)
4. Fomo: $27.83M (p99 $27.83M, success 100.0%, sample n/a)
5. Trojan: $3.47M (p99 $3.47M, success 100.0%, sample n/a)
6. Photon: $1.75M (p99 $1.75M, success 100.0%, sample n/a)
7. BullX: $242.1K (p99 $242.1K, 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: BasedBot leads avg swap size at $148.91 (24h) on Average swap size on Solana: pump.fun vs GMGN vs Fomo vs Axiom, live.

**Rankings (p50, 24h):**
1. BasedBot: $148.91 (p99 $148.91, success 100.0%, sample 95788)
2. GMGN: $137.05 (p99 $137.05, success 100.0%, sample 906976)
3. Maestro: $113.34 (p99 $113.34, success 100.0%, sample 11235)
4. Bloom: $90.35 (p99 $90.35, success 100.0%, sample 13077)
5. Phantom: $67.81 (p99 $67.81, success 100.0%, sample 186146)
6. Photon: $60.53 (p99 $60.53, success 100.0%, sample 23282)
7. Terminal: $50.76 (p99 $50.76, success 100.0%, sample 202211)
8. Trojan: $50 (p99 $50, success 100.0%, sample 54025)
9. Axiom: $47.46 (p99 $47.46, success 100.0%, sample 1375410)
10. pump.fun: $45.91 (p99 $45.91, success 100.0%, sample 292366)
11. Fomo: $35.52 (p99 $35.52, success 100.0%, sample 546956)

**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: Axiom leads unique swap tx 24h at 1.38M (24h) on Unique daily swap transactions on Solana: pump.fun vs GMGN vs Fomo vs Axiom vs Trojan, live.

**Rankings (p50, 24h):**
1. Axiom: 1.38M (p99 1.38M, success 100.0%, sample 1375410)
2. GMGN: 907.0K (p99 907.0K, success 100.0%, sample 906976)
3. Fomo: 547.0K (p99 547.0K, success 100.0%, sample 546956)
4. pump.fun: 292.4K (p99 292.4K, success 100.0%, sample 292366)
5. Terminal: 202.2K (p99 202.2K, success 100.0%, sample 202211)
6. BasedBot: 95.8K (p99 95.8K, success 100.0%, sample 95788)
7. Trojan: 54.0K (p99 54.0K, success 100.0%, sample 54025)
8. Photon: 23.3K (p99 23.3K, success 100.0%, sample 23282)
9. Maestro: 10.2K (p99 10.2K, success 100.0%, sample 10192)

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

## Perp DEX liquidation rate: 24h liquidated notional as % of open interest, live

- Category: Trading
- Metric: Liquidation rate (pct)
- Page: https://openchainbench.com/benchmarks/perp-liq-rate
- JSON: https://openchainbench.com/api/stat/perp-liq-rate
- Status: live
- Headline: Lighter posts the lowest liquidation rate at 0.011% (24h avg) on Perp DEX liquidation rate: 24h liquidated notional as % of open interest, live.

**Rankings (p50, 24h):**
1. Lighter: 0.011% (p99 0.017%, success 100.0%, sample 2880)
2. dYdX v4: 1.70% (p99 2.32%, success 100.0%, sample 2880)
3. Paradex: 4.45% (p99 6.51%, success 100.0%, sample 2880)
4. Hyperliquid: 10.3% (p99 12.2%, success 100.0%, sample 2880)

**Methodology**:
- Cadence: every 5 minutes, in parallel across all venue/asset pairs.
- Sliding window: liquidation events are stored in a 24-hour ring buffer keyed by a dedup string (trade hash or composite timestamp+size key). Events older than 24 hours are pruned on each tick. The window sum is the numerator of the liq rate.
- Hyperliquid: OI from POST /info {type:metaAndAssetCtxs} (openInterest in base units × midPx). Liquidations from 0xArchive GET /v1/hyperliquid/liquidations/{coin} with cursor pagination, covering all liquidation types. Fallback without OXARCHIVE_API_KEY: userFillsByTime on HLP vault address (backstop-only subset).
- dYdX v4: OI from GET /v4/perpetualMarkets (openInterest base units * oraclePrice). Liquidations from GET /v4/trades/perpetualMarket/{ticker}?limit=100 paginated backwards, keeping type == LIQUIDATED rows; notional = size * price.
- GMX v2 (Arbitrum): OI from arbitrum-api.gmxinfra.io/markets/info (openInterestLong + openInterestShort per market, 30-decimal USD, summed across all listed markets for the asset). Liquidation source: unavailable (TheGraph subgraph defunct; Subsquid positionChanges does not expose orderType/isLiquidation). liq_rate and liq_volume are not published for GMX; perp_liq_source_available{venue='gmx'} = 0.
- Lighter: OI from GET /api/v1/orderBookDetails?filter=perp (open_interest in base units × mark_price). Liquidations from Coinalyze /v1/liquidation-history (hourly buckets, symbols 0.T=ETH 1.T=BTC, base asset units × current mark_price). Requires COINALYZE_API_KEY.
- gains.trade (Base): OI from GET backend-base.gains.trade/trading-variables, sum of oiLongCollateral + oiShortCollateral for the USDC collateral at the asset's pair index (BTC=0, ETH=1), divided by 1e6. Liquidations from eth_getLogs on the Gains diamond (0x6cd5ac19...) filtering TradeClosed events with cancelReason=1; notional = collateralAmount/1e6 × leverage/1e3.
- Aevo: OI from GET /statistics?asset=BASE&instrument_type=PERPETUAL (open_interest.total contracts * mark_price). Liquidation source: none; Aevo has no public liquidation feed as of 2025-08. liq_rate and liq_volume are not published; perp_liq_source_available{venue='aevo'} = 0.
- Paradex: OI from GET /v1/markets/summary?market=X (open_interest base units * mark_price). Liquidations from GET /v1/trades?market=X&start_at=<ms>&end_at=<ms> paginated by cursor, keeping trade_type == LIQUIDATION rows.
- Apple-to-apple: OI = current notional USD (collateral × leverage) at all venues. Liquidation events = notional USD of forcibly closed positions. Both sides use the same definition across all venues with available data.
- GMX caveat: liq_rate is effectively 0% due to missing liquidation data; OI is real and per-asset. Do not compare GMX liq_rate to other venues until a working source is added.

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/starknet-rpc
- JSON: https://openchainbench.com/api/stat/starknet-rpc
- Status: live
- Headline: Lava Network posts the lowest rpc latency at 227 ms (p50, 24h) on Fastest free Starknet RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Lava Network: 227 ms (p99 1.80 s, success 99.8%, sample 4312.84)

**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":"starknet_blockNumber","params":[]}. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches.
- 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 block number), http_err, jsonrpc_err (HTTP 200 carrying an error body), stale, 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=starknet. Provider coverage at launch: 5 no-key endpoints (dRPC, Lava, Nethermind, OnFinality, 1RPC).

## Fastest free Stellar Soroban RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/stellar-rpc
- JSON: https://openchainbench.com/api/stat/stellar-rpc
- Status: live
- Headline: Gateway.fm posts the lowest rpc latency at 244 ms (p50, 24h) on Fastest free Stellar Soroban RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Gateway.fm: 244 ms (p99 308 ms, success 93.2%, sample 4317.85)
2. SorobanRPC.com: 302 ms (p99 637 ms, success 97.0%, sample 4309.9)
3. Lightsail Network: 383 ms (p99 2.01 s, success 97.9%, sample 4312.85)
4. Ankr: 712 ms (p99 2.08 s, success 92.1%, sample 4321.84)

**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":"getLatestLedger","params":{}}. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches.
- 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 ledger sequence), http_err, jsonrpc_err (HTTP 200 carrying an error body), stale (more than 10 ledgers 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=stellar. Provider coverage at launch: 5 no-key Soroban endpoints (Gateway.fm, Ankr, OnFinality, SorobanRPC.com, Lightsail Network).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/sui-rpc
- JSON: https://openchainbench.com/api/stat/sui-rpc
- Status: live
- Headline: OnFinality posts the lowest rpc latency at 105 ms (p50, 24h) on Fastest free Sui RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. OnFinality: 105 ms (p99 2.59 s, success 100.0%, sample 4318.84)
2. PublicNode: 106 ms (p99 2.19 s, success 98.9%, sample 4313.87)
3. BlockVision: 144 ms (p99 2.95 s, success 72.9%, sample 4314.84)
4. Suiet: 256 ms (p99 1.95 s, success 99.2%, sample 4318.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":"sui_getLatestCheckpointSequenceNumber","params":[]}. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches.
- 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 checkpoint sequence number), http_err, jsonrpc_err (HTTP 200 carrying an error body), stale (checkpoint more than 100 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=sui. Provider coverage at launch: 5 no-key endpoints (Mysten Labs, PublicNode, BlockVision, Suiet, OnFinality).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/aptos-rpc
- JSON: https://openchainbench.com/api/stat/aptos-rpc
- Status: live
- Headline: Aptos Labs (Fullnode) posts the lowest rpc latency at 79 ms (p50, 24h) on Fastest free Aptos RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Aptos Labs (Fullnode): 79 ms (p99 304 ms, success 100.0%, sample 4318.84)
2. Aptos Labs: 80 ms (p99 307 ms, success 100.0%, sample 4319.84)

**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: HTTP GET to <base>/v1/ with Accept: application/json. Pure REST endpoint, no API key in any request. The response JSON includes block_height (decimal string) and ledger_version.
- 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 block_height), http_err, stale (block more than 300 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=aptos. Provider coverage at launch: 2 no-key endpoints (Aptos Labs api, Aptos Labs fullnode).

## Fastest free XRP Ledger RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/xrp-rpc
- JSON: https://openchainbench.com/api/stat/xrp-rpc
- Status: live
- Headline: Ripple posts the lowest rpc latency at 817 ms (p50, 24h) on Fastest free XRP Ledger RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Ripple: 817 ms (p99 1.07 s, success 99.9%, sample 4311.84)

**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: {"method":"ledger_current","params":[{}]}. Plain HTTP POST. XRPL uses its own JSON-RPC envelope (no jsonrpc:2.0 field); errors are signalled via result.status='error'. Non-cacheable by design.
- 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 + result.ledger_current_index present and non-zero), http_err, jsonrpc_err, stale (ledger more than 75 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=xrp. Provider coverage at launch: 3 no-key endpoints (Ripple, XRPL Labs, PublicNode).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/algorand-rpc
- JSON: https://openchainbench.com/api/stat/algorand-rpc
- Status: live
- Headline: Tatum posts the lowest rpc latency at 21 ms (p50, 24h) on Fastest free Algorand RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Tatum: 21 ms (p99 70 ms, success 100.0%, sample 4313.84)
2. AlgoNode: 131 ms (p99 1.20 s, success 99.3%, sample 4313.86)
3. Nodely: 133 ms (p99 1.76 s, success 99.7%, sample 4309.84)

**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: HTTP GET to <base>/v2/status with Accept: application/json. Pure REST endpoint, no API key in any request. The response JSON includes last-round (integer round number).
- 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 last-round), http_err, stale (round more than 90 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=algorand. Provider coverage at launch: 3 no-key endpoints (AlgoNode, Nodely, Tatum).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/gram-rpc
- JSON: https://openchainbench.com/api/stat/gram-rpc
- Status: live
- Headline: Tatum posts the lowest rpc latency at 30 ms (p50, 24h) on Fastest free Gram RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Tatum: 30 ms (p99 104 ms, success 100.0%, sample 4313.84)
2. OnFinality: 228 ms (p99 2.58 s, success 100.0%, sample 4310.84)
3. TON Center: 264 ms (p99 1.58 s, success 99.3%, sample 4319.86)

**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":"getMasterchainInfo","params":{}}. Plain HTTP POST. The harness handles both the toncenter {ok,result} envelope and standard JSON-RPC 2.0 responses from other providers.
- 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 result.last.seqno), http_err, jsonrpc_err, stale (seqno more than 60 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=gram. Provider coverage at launch: 4 endpoints (TON Center, OnFinality, Tatum, Uniblock).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/near-rpc
- JSON: https://openchainbench.com/api/stat/near-rpc
- Status: live
- Headline: FastNEAR posts the lowest rpc latency at 25 ms (p50, 24h) on Fastest free NEAR RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. FastNEAR: 25 ms (p99 61 ms, success 100.0%, sample 4316.84)
2. dRPC: 182 ms (p99 1.11 s, success 89.8%, sample 4317.84)
3. Lava: 299 ms (p99 1.48 s, success 100.0%, sample 4312.84)
4. NEAR Foundation: 3.02 s (p99 3.06 s, success 100.0%, sample 4317.84)

**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":"block","params":{"finality":"final"}}. Plain HTTP POST. The response carries result.header.height as a decimal uint64.
- 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 result.header.height), http_err, jsonrpc_err, stale (block more than 300 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=near. Provider coverage at launch: 4 endpoints (NEAR Foundation, FastNEAR, Lava, dRPC).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/flow-rpc
- JSON: https://openchainbench.com/api/stat/flow-rpc
- Status: live
- Headline: Flow Access Node posts the lowest rpc latency at 81 ms (p50, 24h) on Fastest free Flow RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Flow Access Node: 81 ms (p99 332 ms, success 100.0%, sample 4313.84)
2. Flow Foundation: 84 ms (p99 333 ms, success 100.0%, sample 4317.84)

**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: HTTP GET to <base>/v1/blocks?height=sealed with Accept: application/json. Pure REST endpoint, no API key. The response is a JSON array; [0].header.height is parsed as a decimal string.
- 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 height), http_err, stale (block more than 240 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=flow. Provider coverage at launch: 2 endpoints (Flow Foundation REST, Flow access node).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/hedera-rpc
- JSON: https://openchainbench.com/api/stat/hedera-rpc
- Status: live
- Headline: Hashio posts the lowest rpc latency at 244 ms (p50, 24h) on Fastest free Hedera RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Hashio: 244 ms (p99 1.31 s, success 98.3%, sample 4309.84)

**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. Standard Ethereum JSON-RPC 2.0; Hedera's Hashio layer is EVM-compatible.
- 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 block number), http_err, jsonrpc_err, stale (block more than 100 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=hedera. Provider coverage at launch: 2 endpoints (Hashio, thirdweb).

## Fastest free Nervos CKB RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/ckb-rpc
- JSON: https://openchainbench.com/api/stat/ckb-rpc
- Status: live
- Headline: CKBapp posts the lowest rpc latency at 53 ms (p50, 24h) on Fastest free Nervos CKB RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. CKBapp: 53 ms (p99 2.80 s, success 99.1%, sample 4315.84)
2. Nervos Foundation: 191 ms (p99 1.33 s, success 100.0%, sample 4318.84)

**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":"get_tip_block_number","params":[]}. Plain HTTP POST. The result field is a hex-encoded block number string (0x prefix).
- 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 (block more than 30 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=ckb. Provider coverage at launch: 2 endpoints (Nervos Foundation, CKBapp).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/multiversx-rpc
- JSON: https://openchainbench.com/api/stat/multiversx-rpc
- Status: live
- Headline: MultiversX Gateway posts the lowest rpc latency at 181 ms (p50, 24h) on Fastest free MultiversX RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. MultiversX Gateway: 181 ms (p99 487 ms, success 100.0%, sample 4311.84)
2. Elrond API: 221 ms (p99 783 ms, success 100.0%, sample 4306.84)
3. MultiversX API: 300 ms (p99 1.50 s, success 99.7%, sample 4308.86)

**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: HTTP GET to <base>/network/status/4294967295 with Accept: application/json. The shard ID 4294967295 (0xFFFFFFFF) is the MultiversX metachain identifier. The response carries data.status.erd_nonce as a decimal uint64.
- 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 erd_nonce), http_err, stale (nonce more than 50 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=multiversx. Provider coverage at launch: 3 endpoints (MultiversX Gateway, MultiversX API, Elrond API).

## Fastest free NEO N3 RPC, live no-key endpoint latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/neo-rpc
- JSON: https://openchainbench.com/api/stat/neo-rpc
- Status: live
- Headline: NGD (2) posts the lowest rpc latency at 3 ms (p50, 24h) on Fastest free NEO N3 RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. NGD (2): 3 ms (p99 22 ms, success 100.0%, sample 4314.84)
2. NGD: 3 ms (p99 21 ms, success 100.0%, sample 4317.84)
3. NSPCC: 168 ms (p99 1.18 s, success 100.0%, sample 4317.84)

**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":"getblockcount","params":[]}. Plain HTTP POST. The result is a decimal integer (block count = current height + 1).
- 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 block count), http_err, jsonrpc_err, stale (block more than 20 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=neo. Provider coverage at launch: 3 endpoints (NSPCC, NGD seed 1, NGD seed 2).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/tezos-rpc
- JSON: https://openchainbench.com/api/stat/tezos-rpc
- Status: live
- Headline: TezBeta posts the lowest rpc latency at 192 ms (p50, 24h) on Fastest free Tezos RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. TezBeta: 192 ms (p99 785 ms, success 99.9%, sample 4320.87)
2. TzKT (Baking Bad): 290 ms (p99 692 ms, success 98.8%, sample 4313.86)
3. SmartPy: 294 ms (p99 671 ms, success 100.0%, sample 4318.84)
4. TCInfra: 481 ms (p99 2.30 s, success 99.6%, sample 4314.86)

**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: HTTP GET /chains/main/blocks/head/header. Plain REST call. The response carries a JSON object with the level field as a plain integer.
- 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 level integer), http_err, jsonrpc_err, stale (block more than 10 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=tezos. Provider coverage at launch: 4 endpoints (SmartPy, TezBeta, TzKT, TCInfra).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/eos-rpc
- JSON: https://openchainbench.com/api/stat/eos-rpc
- Status: live
- Headline: EOS Nation posts the lowest rpc latency at 216 ms (p50, 24h) on Fastest free EOS RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. EOS Nation: 216 ms (p99 1.04 s, success 100.0%, sample 4313.84)
2. Greymass: 259 ms (p99 1.84 s, success 99.2%, sample 4313.85)
3. Aloha EOS: 942 ms (p99 1.64 s, success 100.0%, sample 4309.84)

**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: HTTP GET /v1/chain/get_info. Plain REST call. The response carries head_block_num as a plain integer.
- 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 head_block_num integer), http_err, jsonrpc_err, stale (block more than 600 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=eos. Provider coverage at launch: 3 endpoints (Greymass, EOS Nation, Aloha EOS).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/vechain-rpc
- JSON: https://openchainbench.com/api/stat/vechain-rpc
- Status: live
- Headline: VeThor Node posts the lowest rpc latency at 191 ms (p50, 24h) on Fastest free VeChain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. VeThor Node: 191 ms (p99 858 ms, success 100.0%, sample 4320.84)
2. VeChain Foundation: 191 ms (p99 830 ms, success 99.9%, sample 4316.84)
3. VeChain.energy: 297 ms (p99 1.62 s, success 99.9%, sample 4314.84)

**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: HTTP GET /blocks/best. Plain REST call. The response carries number as a plain unsigned integer.
- 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 number integer), http_err, jsonrpc_err, stale (block more than 30 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=vechain. Provider coverage at launch: 3 endpoints (VeChain Foundation x2, VeChain.energy).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/waves-rpc
- JSON: https://openchainbench.com/api/stat/waves-rpc
- Status: live
- Headline: Waves.Exchange posts the lowest rpc latency at 204 ms (p50, 24h) on Fastest free Waves RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Waves.Exchange: 204 ms (p99 546 ms, success 100.0%, sample 4316.84)
2. Waves Exchange Node: 205 ms (p99 583 ms, success 100.0%, sample 4316.84)
3. Waves Foundation: 346 ms (p99 913 ms, success 100.0%, sample 4322.84)

**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: HTTP GET /blocks/last. Plain REST call. The response carries height as a plain integer.
- 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 height integer), http_err, jsonrpc_err, stale (block more than 5 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=waves. Provider coverage at launch: 3 endpoints (Waves Foundation, Waves.Exchange x2).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/wax-rpc
- JSON: https://openchainbench.com/api/stat/wax-rpc
- Status: live
- Headline: Greymass posts the lowest rpc latency at 292 ms (p50, 24h) on Fastest free WAX RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. Greymass: 292 ms (p99 2.11 s, success 99.3%, sample 4316.86)
2. WAX Sweden: 511 ms (p99 1.18 s, success 100.0%, sample 4313.84)
3. EOSUSA: 674 ms (p99 783 ms, success 100.0%, sample 4320.84)

**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: HTTP GET /v1/chain/get_info. Plain REST call. The response carries head_block_num as a plain integer.
- 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 head_block_num integer), http_err, jsonrpc_err, stale (block more than 600 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=wax. Provider coverage at launch: 3 endpoints (Greymass, EOSUSA, WAX Sweden).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/neon-rpc
- JSON: https://openchainbench.com/api/stat/neon-rpc
- Status: live
- Headline: P2P Neon Proxy posts the lowest rpc latency at 200 ms (p50, 24h) on Fastest free Neon EVM RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. P2P Neon Proxy: 200 ms (p99 676 ms, success 100.0%, sample 4313.84)
2. Everstake: 201 ms (p99 686 ms, success 100.0%, sample 4317.84)

**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. Standard Ethereum JSON-RPC 2.0; Neon EVM exposes a full EVM-compatible interface.
- 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 block number), http_err, jsonrpc_err, stale, 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=neon. Provider coverage at launch: 3 endpoints (P2P Neon Proxy, Thirdweb, Everstake).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/merlin-rpc
- JSON: https://openchainbench.com/api/stat/merlin-rpc
- Status: live
- Headline: BlockPI posts the lowest rpc latency at 18 ms (p50, 24h) on Fastest free Merlin Chain RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. BlockPI: 18 ms (p99 215 ms, success 100.0%, sample 4311.84)
2. Merlin Official: 80 ms (p99 1.93 s, success 99.0%, sample 4309.85)
3. dRPC: 446 ms (p99 1.01 s, success 82.2%, sample 4315.84)

**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. Standard Ethereum JSON-RPC 2.0.
- 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 block number), http_err, jsonrpc_err, stale, 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=merlin. Provider coverage at launch: 3 endpoints (Merlin Official, dRPC, BlockPI).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/viction-rpc
- JSON: https://openchainbench.com/api/stat/viction-rpc
- Status: live
- Headline: dRPC posts the lowest rpc latency at 13 ms (p50, 24h) on Fastest free Viction RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. dRPC: 13 ms (p99 158 ms, success 89.8%, sample 4317.84)
2. Viction Official: 142 ms (p99 2.31 s, success 99.1%, sample 4310.84)
3. Viction RPC2: 145 ms (p99 1.91 s, success 99.3%, sample 4316.84)

**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. Standard Ethereum JSON-RPC 2.0.
- 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 block number), http_err, jsonrpc_err, stale, 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=viction. Provider coverage at launch: 3 endpoints (Viction Official, Viction RPC2, dRPC).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/thundercore-rpc
- JSON: https://openchainbench.com/api/stat/thundercore-rpc
- Status: live
- Headline: ThunderCore Official posts the lowest rpc latency at 37 ms (p50, 24h) on Fastest free ThunderCore RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. ThunderCore Official: 37 ms (p99 313 ms, success 100.0%, sample 4316.84)
2. ThunderToken: 37 ms (p99 381 ms, success 100.0%, sample 4311.84)
3. dRPC: 200 ms (p99 628 ms, success 88.7%, sample 4312.84)

**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. Standard Ethereum JSON-RPC 2.0.
- 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 block number), http_err, jsonrpc_err, stale, 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=thundercore. Provider coverage at launch: 3 endpoints (ThunderCore Official, ThunderToken, dRPC).

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

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/oktc-rpc
- JSON: https://openchainbench.com/api/stat/oktc-rpc
- Status: live
- Headline: OKX Chain Official posts the lowest rpc latency at 50 ms (p50, 24h) on Fastest free OKTC RPC, live no-key endpoint latency.

**Rankings (p50, 24h):**
1. OKX Chain Official: 50 ms (p99 157 ms, success 96.3%, sample 4311.84)
2. dRPC: 395 ms (p99 728 ms, success 89.7%, sample 4311.84)

**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. Standard Ethereum JSON-RPC 2.0.
- 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 block number), http_err, jsonrpc_err, stale, 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 benchmark; the identical harness, cadence and exclusion rules apply on every chain.
- Chain scope: every query on this page is pinned to chain=oktc. Provider coverage at launch: 3 endpoints (OKX Chain Official, 1RPC, dRPC).

## Daily active wallets per trading platform: GMGN vs Axiom vs Fomo vs pump.fun, live

- Category: Trading
- Metric: Active wallets 24h (count)
- Page: https://openchainbench.com/benchmarks/trading-platform-wallets
- JSON: https://openchainbench.com/api/stat/trading-platform-wallets
- Status: live
- Headline: Fomo leads active wallets 24h at 63.3K (24h) on Daily active wallets per trading platform: GMGN vs Axiom vs Fomo vs pump.fun, live.

**Rankings (p50, 24h):**
1. Fomo: 63.3K (p99 63.3K, success 100.0%, sample 63281)
2. Axiom: 48.6K (p99 48.6K, success 100.0%, sample 48564)
3. GMGN: 39.3K (p99 39.3K, success 100.0%, sample 39285)
4. pump.fun: 13.5K (p99 13.5K, success 100.0%, sample 13472)
5. BasedBot: 12.4K (p99 12.4K, success 100.0%, sample 12449)
6. Terminal: 9,099 (p99 9,099, success 100.0%, sample 9099)
7. Trojan: 4,870 (p99 4,870, success 100.0%, sample 4870)
8. Photon: 1,520 (p99 1,520, success 100.0%, sample 1520)

**Methodology**:
- Source: Dune community datasets (dataset_*_daily). wallets column = unique wallet addresses per platform per day.
- Poll cadence: harness queries Dune every 4 hours; Prometheus scrapes :2112/metrics every 60 seconds.
- Cross-chain: GMGN, Axiom, BasedBot, Terminal sum wallets across all blockchains. Fomo and Trojan are Solana-only datasets.
- pump.fun: dataset_pumpapp_sol_daily wallets only (pumpapp frontend). Relay dataset wallets not added to avoid double-counting wallets active on both.
- Includes all wallets: bots, MEV searchers, and automated traders are counted. Not a human-only metric.
- Not mutually exclusive: a wallet using GMGN and Axiom on the same day is counted in both platforms.

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