# OpenChainBench live state > Auto-refreshed every 60s · last fetch 2026-09-10T03:30:04.300Z · 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: Serialized posts the lowest head lag at 0.7 s (p50, 24h) on Fastest crypto price API, live head lag across Mobula, Codex, GeckoTerminal. **Rankings (p50, 24h):** 1. Serialized: 0.7 s (p99 1.4 s, success 7.9%, sample 5475) 2. Codex: 0.8 s (p99 1.8 s, success 49.7%, sample 34384) 3. Mobula: 1.0 s (p99 9.2 s, success 49.8%, sample 34444) 4. GeckoTerminal: 35 s (p99 2.0 min, success 49.7%, sample 34373) **Methodology**: - Aggregators measured: Mobula, Codex, GeckoTerminal, Serialized. - Chains: Base, BNB Chain, Solana, Robinhood Chain. - Reference on BNB Chain, Solana and Robinhood Chain: archive nodes per chain, validated against block hashes. These carry no preconfirmation layer a provider consumes, and their chain-supplied timestamps sit within roughly 60 ms of the moment a trade is observable, so they keep the on-chain timestamp as the zero point. - Regions: us-east, eu-west, sgp. Cross-region median reported in the headline. - Reference on Base: the sequencer's flashblock preconfirmation stream, held by us in every region. A Base block becomes queryable about 0.36 s after the timestamp it carries, while flashblocks publish every 200 ms inside the 2 s interval, so that timestamp is not the moment a trade becomes knowable. - Base emissions we cannot match to a flashblock are dropped rather than measured against a different ruler. Measuring against the block timestamp charged a provider reading preconfirmations with a negative lag, and described the chain's stamping convention rather than the provider's pipeline. - 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: 4 aggregators × 4 chains × 3 regions = 48 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: Across posts the lowest quote latency at 131 ms (p50, 24h) on Fastest cross-chain bridge quote API, live ms ranking. **Rankings (p50, 24h):** 1. Across: 131 ms (p99 4.39 s, success 99.7%, sample 286.099) 2. Squid Router: 348 ms (p99 1.28 s, success 100.0%, sample 287.1) 3. deBridge: 417 ms (p99 4.84 s, success 100.0%, sample 287.1) 4. Relay: 761 ms (p99 2.00 s, success 94.2%, sample 270.094) 5. Socket Protocol: 886 ms (p99 1.99 s, success 100.0%, sample 287.1) 6. Mobula: 975 ms (p99 10.00 s, success 100.0%, sample 287.1) 7. LI.FI: 1.57 s (p99 4.73 s, success 100.0%, sample 287.1) 8. Near Intents: 3.51 s (p99 977 ms, success 99.7%, sample 286.099) **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 only at present. The us-east and sgp probes are temporarily paused, so the live figures reflect the EU-West (Paris) origin; the harness is built to probe three origins simultaneously and the other two tabs return when those probes resume. - 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.050%, success 100.0%, sample 2876) 2. Near Intents: 0.067% (p99 0.068%, success 99.7%, sample 14923) 3. Relay: 0.14% (p99 0.28%, success 99.0%, sample 29846) 4. Across: 0.18% (p99 0.21%, success 66.6%, sample 14925) 5. Mobula: 0.23% (p99 0.66%, success 99.3%, sample 29846) 6. Socket Protocol: 0.34% (p99 0.38%, success 100.0%, sample 2876) 7. LI.FI: 0.44% (p99 0.84%, success 100.0%, sample 29846) 8. deBridge: 1.13% (p99 1.56%, success 99.8%, sample 22386) **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 only at present. The us-east and sgp probes are temporarily paused, so the live figures reflect the EU-West (Paris) origin; the other two tabs return when those probes resume. - Failures (quote_failed, unsupported route) excluded from cost aggregates and counted toward success rate. - Provider types are surfaced as badges: direct protocols (deBridge) charge their own bridging fees; aggregators (LI.FI) route through whichever underlying bridge is cheapest, so their effective fee includes that bridge's cost plus any aggregator markup; intent / relay layers (Mobula, Relay, Across, Near Intents) bake cost into the spread of a settlement intent or optimistic fill rather than charging an explicit fee. - Excluded by design: Stargate, because its keyless quote endpoint was deprecated in favor of a key-gated LayerZero API, and its on-chain quoteOFT path is same-asset EVM-only, which matches none of this bench's corridors. CCTP, because Circle's burn/mint has no quote that returns a delivered amount; standard transfers mint 1:1 and the whole cost is user-paid gas we would have to estimate ourselves, which breaks the quoted USD in minus quoted USD delivered definition used for every other row. ## Best crypto data API for token metadata, live across Mobula, Codex, Jupiter - Category: Aggregators - Metric: Field coverage (pct) - Page: https://openchainbench.com/benchmarks/metadata-coverage - JSON: https://openchainbench.com/api/stat/metadata-coverage - Status: live - Headline: Codex leads field coverage at 66.1% (24h avg) on Best crypto data API for token metadata, live across Mobula, Codex, Jupiter. **Rankings (p50, 24h):** 1. Codex: 66.1% (p99 73.9%, success 100.0%, sample 70164.4) 2. Mobula: 60.6% (p99 73.3%, success 100.0%, sample 70164.4) 3. Jupiter: 5.22% (p99 37.5%, success 100.0%, sample 31711) **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/`, 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 466 (24h) on Crypto data API with most blockchains in asset registry, live coverage ranking. **Rankings (p50, 24h):** 1. CoinGecko: 466 (p99 466, success 100.0%, sample 466) 2. CoinPaprika: 310 (p99 310, success 100.0%, sample 310) 3. CoinStats: 149 (p99 149, success 100.0%, sample 149) 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 1.2 s, success 99.5%, sample 205731) 2. BNB: 0.9 s (p99 2.0 s, success 98.8%, sample 129907) 3. Avalanche: 1.4 s (p99 3.0 s, success 99.1%, sample 73667.6) 4. Stellar: 7.1 s (p99 18 s, success 100.0%, sample 11862.1) 5. Solana: 10.0 s (p99 12 s, success 99.8%, 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: 18.7 min (p99 33.4 min, success 100.0%, sample 2880) 9. Litecoin: 31.7 min (p99 54.2 min, success 99.3%, sample 2880) 10. Bitcoin: 54.0 min (p99 101.0 min, success 100.0%, sample 151.052) **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.0014% (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.0014% (p99 0.0065%, success 100.0%, sample 2880) 2. Extended: 0.026% (p99 0.035%, success 100.0%, sample 2880) 3. Paradex: 0.039% (p99 0.31%, success 100.0%, sample 2880) 4. Gains: 0.040% (p99 0.040%, success 100.0%, sample 2880) 5. Polymarket: 0.043% (p99 0.065%, success 100.0%, sample 2880) 6. Hyperliquid: 0.046% (p99 0.053%, success 100.0%, sample 2880) 7. Aster: 0.050% (p99 0.057%, success 100.0%, sample 2880) 8. GMX v2: 0.060% (p99 0.060%, success 99.7%, sample 2880) 9. dYdX v4: 0.077% (p99 0.16%, 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 (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//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) 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: Mobula leads coverage rate at 54.9% (24h avg) on Best wallet labeling API provider. **Rankings (p50, 24h):** 1. Mobula: 54.9% (p99 54.9%, success 99.9%, sample 8638.99) 2. Blockscout: 48.7% (p99 48.7%, success 86.7%, sample 4029.4) 3. OLI: 45.6% (p99 45.6%, success 100.0%, sample 5579.93) 4. TonAPI: 35.6% (p99 35.6%, success 78.4%, sample 680.236) **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 81 ms (p50, 24h) on Fastest L2 block time, live across Robinhood, Arbitrum, Base and 7 more. **Rankings (p50, 24h):** 1. Robinhood Chain: 81 ms (p99 198 ms, success 100.0%, sample 856504) 2. Arbitrum One: 334 ms (p99 500 ms, success 99.1%, sample 338811) 3. Mantle: 1.83 s (p99 3.77 s, success 99.0%, sample 41961.6) 4. Optimism: 1.94 s (p99 2.98 s, success 99.1%, sample 42505.8) 5. Base: 1.95 s (p99 2.98 s, success 99.1%, sample 42550.8) 6. Taiko: 1.98 s (p99 3.22 s, success 98.7%, sample 41762.5) 7. Blast: 1.98 s (p99 2.98 s, success 97.4%, sample 40783.2) 8. Scroll: 2.52 s (p99 53.94 s, success 98.7%, sample 13042.5) 9. zkSync Era: 3.98 s (p99 52.44 s, success 99.5%, sample 11635) 10. Linea: 5.09 s (p99 45.19 s, success 98.8%, sample 10233.6) **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 74 ms (p50, 24h) on Fastest free public RPC for Ethereum, BNB, Polygon and 23 more chains (plus Solana and Polkadot). **Rankings (p50, 24h):** 1. Binance: 74 ms (p99 364 ms, success 100.0%, sample 4314.76) 2. PublicNode: 153 ms (p99 543 ms, success 80.9%, sample 294736) 3. Avalanche: 200 ms (p99 251 ms, success 100.0%, sample 4318.76) 4. dRPC: 223 ms (p99 604 ms, success 90.2%, sample 294433) 5. Nodies: 238 ms (p99 429 ms, success 66.7%, sample 25898.5) 6. Arbitrum: 257 ms (p99 408 ms, success 100.0%, sample 4318.76) 7. Base: 260 ms (p99 425 ms, success 100.0%, sample 4319.76) 8. MeowRPC: 269 ms (p99 551 ms, success 99.3%, sample 8631.51) 9. Tenderly: 272 ms (p99 301 ms, success 96.5%, sample 125091) 10. Optimism: 341 ms (p99 426 ms, success 100.0%, sample 4320.76) 11. NOWNodes: 370 ms (p99 593 ms, success 97.9%, sample 8433.17) 12. Flashbots: 701 ms (p99 1.09 s, success 100.0%, sample 4320.76) **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":,"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: Owlracle posts the lowest gap vs realized at ~0 gwei (p50, 24h) on Most accurate gas oracle, live gap vs realized priority fee. **Rankings (p50, 24h):** 1. Owlracle: ~0 gwei (p99 ~0 gwei, success 96.0%, sample 5758) 2. MetaMask: ~0 gwei (p99 0 gwei, success 97.4%, sample 28802) 3. PublicNode: ~0 gwei (p99 0 gwei, success 95.9%, sample 28799) 4. Etherscan: 0.010 gwei (p99 0 gwei, success 98.7%, sample 17280) **Methodology**: - Chains: Ethereum (chainid=1), Polygon PoS (chainid=137), Arbitrum One (chainid=42161). Ethereum and Polygon are EIP-1559 with dynamic base fee. Arbitrum is included as an L2 reference where priority fee converges to ~0 (centralised sequencer, no MEV auction); the bench shows this empirically. Actually-meaningful L2 cost is L1 data fee, planned for a separate bench. BNB Chain excluded (not EIP-1559). Avalanche C-Chain also collapses to ~0 priority. - Oracles per chain. Ethereum + Polygon: PublicNode feeHistory, Owlracle, Etherscan v2 (free tier), MetaMask. Avalanche: same set minus Etherscan (free plan restricted for chainid 43114). - Per-oracle endpoints. PublicNode `eth_feeHistory` on each chain's RPC; Owlracle `/v4/{eth|poly|avax}/gas` (slug per chain); Etherscan v2 `?chainid=&module=gastracker&action=gasoracle`; MetaMask `gas.api.cx.metamask.io/networks//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_`; 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.00063% (24h avg) on Most stable stablecoin, live peg deviation across USDC, USDT and DAI. **Rankings (p50, 24h):** 1. DAI: 0.00063% (p99 0.0028%, success 100.0%, sample 7200.5) 2. USDC: 0.015% (p99 0.016%, success 100.0%, sample 51840) 3. USDT: 0.025% (p99 0.042%, success 100.0%, sample 51840) **Methodology**: - Sources per stable, USDC: Binance USDC/USDT (USDT-anchored, secondary), Kraken USDCUSD, Bitstamp usdcusd. USDT: Coinbase USDT-USD, Kraken USDTUSD, Bitstamp usdtusd. FDUSD: Binance FDUSDUSDT (USDT-anchored, secondary). USDe: Binance USDEUSDT (USDT-anchored, secondary). DAI: Curve 3pool `get_dy`, quoted forward (USDC → DAI) and reverse (DAI → USDC), published as the geometric mean of the two quotes. - DAI's source class differs from the rest. No liquid CEX USD pair for DAI exists (live check July 2026: Kraken DAIUSD under $150k per 24 h with a 9 bps spread, Bitstamp at zero volume, Coinbase DAI-USD delisted), so DAI is measured from the Curve 3pool on-chain quote while USDC and USDT come from CEX tickers. The geometric mean of forward and reverse `get_dy` cancels the pool swap fee; residual pool imbalance is DAI's genuine price signal, not an artifact. - Cadence: 5 seconds for CEX REST tickers, 12 seconds for Curve `get_dy` on-chain (matches Ethereum block time). Per-venue samples are grouped into 60-second buckets for the liquidity-weighted median aggregation. - Aggregation: per-minute liquidity-weighted median across USD-quoted venues (`Quote = QuoteUSD`). Weight is 24 h USD volume estimate. The aggregated price drives `peg_deviation_bps` (per-minute median, retained for backward compatibility) and `peg_deviation_bps_histogram`. - Primary headline: `peg_deviation_worst_bps`, the per-minute MAX |price - $1.00| across all venue samples in the 60-second bucket, in bps. The ledger sorts on `quantile_over_time(0.50, peg_deviation_worst_bps[24h])`, the 24 h median (everyday tightness); the p99 column is the depeg tail. Per-minute max surfaces sub-minute depeg wicks a median would smooth away. Gauges `peg_minute_min_bps`, `peg_minute_open_bps`, `peg_minute_close_bps` expose the bar shape. - Cross-venue gap (OCB-only number): `max(price across USD-quoted venues) - min(price)`, per minute, in basis points. Surfaces the windows where Coinbase quotes USDT at $1.0003 while Kraken quotes $0.9978. Stored as `peg_cross_venue_gap_bps`. - USDT-anchored secondary metric: Binance USDC/USDT, FDUSD/USDT and USDE/USDT are exposed on `peg_deviation_usdt_anchored_bps{venue}` separately so the USD-anchored primary leaderboard is not contaminated by USDT's own peg deviation. - Time outside band: total seconds in the trailing 24 h during which the per-minute aggregated price fell outside [0.995, 1.005] (±50 bps). Split into `peg_time_below_peg_24h_seconds` (< 0.995) and `peg_time_above_peg_24h_seconds` (> 1.005) because Circle redemption only clears above-peg, so the direction tells you which failure mode is active. - Depeg event flag: binary `peg_depeg_event_flag` set to 1 when the per-minute aggregated price has been outside [0.97, 1.03] for ≥5 consecutive minutes; cleared after 30 minutes back inside. Conservative so it does not flap during normal stress events. - Outlier rule (multi-venue consensus): a sample more than 2% off peg is kept only when at least one other venue was outside the same band in the same direction within the last 30 seconds. Isolated single-venue glitches are dropped as `dropped_isolated`; corroborated moves (Kraken AND Bitstamp both at $0.87) are kept as `kept_corroborated`, so a real depeg like USDC during SVB in March 2023 survives into the percentile metric. Anything more than 50% off peg is treated as a parser bug and dropped. - Excluded by design: aggregator-only prices (CoinGecko, Coinmarketcap, DefiLlama) because they are themselves liquidity-weighted medians of the venues we already poll directly. Algo-stables that have already failed (UST, USDR) are out of scope; the bench tracks live, currently-redeemable stables. ## Cheapest USDT stablecoin swap on Binance, live USDC, FDUSD, USDe spread - Category: Trading - Metric: USDT-pair spread (bps) - Page: https://openchainbench.com/benchmarks/stablecoin-peg-usdt-anchored - JSON: https://openchainbench.com/api/stat/stablecoin-peg-usdt-anchored - Status: live - Headline: USDe posts the lowest usdt-pair spread at 0.0050% (24h avg) on Cheapest USDT stablecoin swap on Binance, live USDC, FDUSD, USDe spread. **Rankings (p50, 24h):** 1. USDe: 0.0050% (p99 0.025%, success 100.0%, sample 17280) 2. USDC: 0.011% (p99 0.026%, success 100.0%, sample 17280) 3. FDUSD: 0.10% (p99 0.14%, success 100.0%, sample 17280) **Methodology**: - Source: Binance REST `/api/v3/ticker/bookTicker?symbol=` 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 100.8% (24h avg) on DeFi token buyback tracker, live executed vs promised ratio. **Rankings (p50, 24h):** 1. Hyperliquid: 100.8% (p99 100.8%, success 100.0%, sample 11910900) **Methodology**: - Promised USD, DeFiLlama `summary/fees/` 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: LINK/USD posts the lowest max cross-oracle deviation at 0.017% (24h avg) on Chainlink vs Pyth vs Binance vs Coinbase, live oracle deviation. **Rankings (p50, 24h):** 1. LINK/USD: 0.017% (p99 0.11%, success 75.0%, sample 11520) 2. SOL/USD: 0.019% (p99 0.059%, success 75.0%, sample 11520) 3. ETH/USD: 0.019% (p99 0.050%, success 75.0%, sample 11520) 4. XRP/USD: 0.021% (p99 0.063%, success 66.7%, sample 8640) 5. BTC/USD: 0.022% (p99 0.047%, success 75.0%, sample 11520) 6. DOGE/USD: 0.022% (p99 0.099%, success 66.7%, sample 8640) 7. ADA/USD: 0.023% (p99 0.11%, success 66.7%, sample 8640) 8. BNB/USD: 0.025% (p99 0.083%, success 75.0%, sample 11520) 9. AVAX/USD: 0.025% (p99 0.100%, success 75.0%, sample 11520) 10. POL/USD: 0.042% (p99 0.27%, success 75.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/

/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.88% (24h avg) on Highest staking yield, live validator net APR across 7 PoS chains. **Rankings (p50, 24h):** 1. Cosmos Hub: 9.88% (p99 9.88%, success 100.0%, sample 180) 2. Avalanche: 6.80% (p99 8.33%, success 100.0%, sample 100) 3. Solana: 5.02% (p99 5.41%, success 100.0%, sample 200) 4. Cardano: 4.95% (p99 5.00%, success 100.0%, sample 50) 5. Ethereum: 2.54% (p99 2.54%, success 100.0%, sample 1) 6. Hyperliquid: 2.17% (p99 2.24%, success 100.0%, sample 35) **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), Hyperliquid `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 $57.9K (24h) on Hyperliquid frontends builder revenue leaderboard. **Rankings (p50, 24h):** 1. MetaMask: $57.9K (p99 $40.2, success 100.0%, sample 22669) 2. Trust Wallet: $56.2K (p99 $34.18, success 100.0%, sample 18442) 3. Phantom: $37.9K (p99 $8.55, success 100.0%, sample 51077) 4. FOMO: $31.0K (p99 $11.99, success 100.0%, sample 36977) 5. Invo: $11.2K (p99 $1.55, success 100.0%, sample 70161) 6. Insilico: $10.9K (p99 $38.94, success 100.0%, sample 42142) 7. Rabby: $10.5K (p99 $9.43, success 100.0%, sample 23171) 8. Hyperdash: $9,712.44 (p99 $36.11, success 100.0%, sample 21145) 9. 0x7cc0…e781: $7,889.99 (p99 $2.48, success 100.0%, sample 25559) 10. 0xdbc2…97a6: $6,852.42 (p99 $67.85, success 100.0%, sample 1149) 11. Liquid Perps: $6,685.55 (p99 $11.65, success 100.0%, sample 14585) 12. OneKey: $5,870.32 (p99 $34.94, success 100.0%, sample 3164) 13. Bitget Wallet: $5,050.6 (p99 $18.43, success 100.0%, sample 2897) 14. Legend Trade: $3,737.45 (p99 $5.67, success 100.0%, sample 13908) 15. Markets Mobile: $3,529.41 (p99 $28.69, success 100.0%, sample 3150) 16. 0x42f3…f992: $2,493.44 (p99 $17.68, success 100.0%, sample 16079) 17. Mass.money: $2,402.12 (p99 $24.26, success 100.0%, sample 3531) 18. Metascalp: $2,366.66 (p99 $9.28, success 100.0%, sample 33834) 19. based.app: $2,210.76 (p99 $7.92, success 100.0%, sample 9023) 20. Tread.fi: $2,172.35 (p99 $14.78, success 100.0%, sample 62028) 21. Moonbot: $2,146.46 (p99 $21.25, success 100.0%, sample 14649) 22. 0xf85a…5688: $1,696.82 (p99 $36.89, success 100.0%, sample 1158) 23. MetaMask (alt): $1,607.66 (p99 $15.17, success 100.0%, sample 719) 24. VergeX: $1,579.03 (p99 $8.87, success 100.0%, sample 16198) 25. Dreamcash: $1,243.88 (p99 $6.04, success 100.0%, sample 3412) 26. Dextrabot: $1,193.86 (p99 $66.33, success 100.0%, sample 741) 27. Axiom: $1,167.02 (p99 $3.83, success 100.0%, sample 5174) 28. 0x53a1…fcd1: $1,030.44 (p99 $18.74, success 100.0%, sample 1052) 29. pvp.trade: $1,020.03 (p99 $25.5, success 100.0%, sample 772) 30. Pear: $916.9 (p99 $14.79, success 100.0%, sample 3620) 31. Infinex: $882.65 (p99 $23.23, success 100.0%, sample 1239) 32. STRYX: $859.14 (p99 $286.38, success 100.0%, sample 331) 33. Wunder: $704.72 (p99 $5, success 100.0%, sample 3235) 34. Arena: $625.88 (p99 $24.07, success 100.0%, sample 592) 35. BullpenFi: $609.7 (p99 $7.35, success 100.0%, sample 1138) 36. Wallet V: $603.33 (p99 $28.73, success 100.0%, sample 754) 37. Dexly Trade: $536.86 (p99 $9.76, success 100.0%, sample 895) 38. HyperX: $496.58 (p99 $6.45, success 100.0%, sample 4004) 39. ApexLiquid: $444.83 (p99 $4.36, success 100.0%, sample 4736) 40. 0x446f…d6c6: $373.59 (p99 $46.7, success 100.0%, sample 253) 41. UnityWallet: $325.51 (p99 $27.13, success 100.0%, sample 423) 42. 0x9f83…31d9: $305.77 (p99 $4.19, success 100.0%, sample 705) 43. XBIT: $291.1 (p99 $58.22, success 100.0%, sample 201) 44. Rainbow: $245.77 (p99 $2.96, success 100.0%, sample 741) 45. cro.trade: $205.82 (p99 $13.72, success 100.0%, sample 649) 46. Tradoor: $199.04 (p99 $15.31, success 100.0%, sample 7566) 47. defi.app: $170.62 (p99 $7.42, success 100.0%, sample 338) 48. goodcryptoX: $136.64 (p99 $2.4, success 100.0%, sample 2178) 49. Dexari: $134.78 (p99 $10.37, success 100.0%, sample 243) 50. Nansen: $126.5 (p99 $1.81, success 100.0%, sample 535) 51. Onchain.cc: $114.95 (p99 $0.3897, success 100.0%, sample 1393) 52. tuleep.trade: $109.62 (p99 $36.54, success 100.0%, sample 308) 53. Owly.fi: $108.32 (p99 $10.83, success 100.0%, sample 563) 54. Senpi: $86.45 (p99 $0.4912, success 100.0%, sample 1903) 55. MinaraAI: $77.21 (p99 $0.1364, success 100.0%, sample 3432) 56. CoinPilot: $71.95 (p99 $1.14, success 100.0%, sample 3955) 57. 0xc95d…1aca: $56.68 (p99 $9.45, success 100.0%, sample 5683) 58. Origami Tech: $40.78 (p99 $3.71, success 100.0%, sample 2173) 59. CCXT: $32.77 (p99 $0.4892, success 100.0%, sample 2337) 60. SuperCEXy: $27.07 (p99 $2.71, success 100.0%, sample 401) 61. Splash: $26.25 (p99 $13.13, success 100.0%, sample 53) 62. Hyprearn: $20.61 (p99 $2.94, success 100.0%, sample 133) 63. Sushi: $17.84 (p99 $8.92, success 100.0%, sample 31) 64. Liminal: $16.48 (p99 $16.48, success 100.0%, sample 20) 65. Cwallet: $15.39 (p99 $0.3207, success 100.0%, sample 246) 66. DeFi Saver: $15.02 (p99 $2.5, success 100.0%, sample 55) 67. Okto: $12.2 (p99 $0.4519, success 100.0%, sample 181) 68. Moontrader: $5.24 (p99 $1.05, success 100.0%, sample 47) 69. KuCoin Web3: $5.06 (p99 $1.26, success 100.0%, sample 26) 70. PerpsWLD: $4.65 (p99 $0.6645, success 100.0%, sample 26) 71. Miracle: $4.11 (p99 $0.4106, success 100.0%, sample 179) 72. Gem Wallet: $3.51 (p99 $3.51, success 100.0%, sample 12) 73. Lit Trade: $2.69 (p99 $0.5385, success 100.0%, sample 32) 74. Katoshi: $2.49 (p99 $0.8308, success 100.0%, sample 3) 75. Cipher: $2.2 (p99 $1.1, success 100.0%, sample 18) 76. MarsGO: $2.1 (p99 $2.1, success 100.0%, sample 10) 77. Grider: $0.8585 (p99 $0.8585, success 100.0%, sample 43) 78. VOOI: $0.7022 (p99 $0.0878, success 100.0%, sample 35) 79. Coin98: $0.2730 (p99 $0.1365, success 100.0%, sample 14) 80. GTR Trade: $0.0253 (p99 $0.0253, success 100.0%, sample 2) **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.000122 (24h) on Cheapest blockchain transaction fee, live across 15 L1 and L2 chains. **Rankings (p50, 24h):** 1. Litecoin: $0.000122 (p99 $0.000123, success 70.7%, sample 20160) 2. Base: $0.000317 (p99 $0.3744, success 100.0%, sample 20160) 3. Taiko: $0.000459 (p99 $0.00237, success 100.0%, sample 20160) 4. Solana: $0.000517 (p99 $0.00775, success 100.0%, sample 20160) 5. Mantle: $0.000667 (p99 $0.00434, success 100.0%, sample 20160) 6. BNB Chain: $0.000903 (p99 $0.0382, success 100.0%, sample 20160) 7. Arbitrum One: $0.00105 (p99 $0.00110, success 100.0%, sample 20160) 8. zkSync Era: $0.00237 (p99 $0.00239, success 100.0%, sample 20160) 9. Ethereum: $0.00673 (p99 $0.4090, success 100.0%, sample 20160) 10. Robinhood Chain: $0.00964 (p99 $0.0115, success 99.9%, sample 20160) 11. Linea: $0.0150 (p99 $0.0666, success 100.0%, sample 20160) 12. Cardano: $0.0362 (p99 $0.0370, success 100.0%, sample 20160) 13. Monero: $0.0604 (p99 $0.2462, success 100.0%, sample 20160) 14. TRON: $0.0937 (p99 $0.1046, success 100.0%, sample 20160) **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 232 ms (p50, 24h) on Fastest EVM swap quote API. **Rankings (p50, 24h):** 1. KyberSwap: 232 ms (p99 2.33 s, success 99.7%, sample 4303.36) 2. Mobula: 361 ms (p99 1.44 s, success 100.0%, sample 4319.36) 3. Bebop: 589 ms (p99 2.09 s, success 99.9%, sample 4317.36) 4. LI.FI: 724 ms (p99 2.71 s, success 62.1%, sample 2682.22) 5. Enso: 1.37 s (p99 4.41 s, success 100.0%, sample 4318.36) 6. CoW Protocol: 2.12 s (p99 4.88 s, success 100.0%, sample 3456.29) **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.00117 (24h) on Cheapest blockchain to deploy a token, live USD cost across 7 non-EVM L1 chains. **Rankings (p50, 24h):** 1. Osmosis: $0.00117 (p99 $0.00127, success 100.0%, sample 20160) 2. Aptos: $0.0974 (p99 $0.1024, success 100.0%, sample 20160) 3. Cardano: $0.2548 (p99 $0.2603, success 100.0%, sample 20160) 4. Sui: $0.4027 (p99 $58.02, success 100.0%, sample 20160) 5. Stellar: $0.4640 (p99 $0.4765, success 100.0%, sample 20160) 6. Injective: $0.6187 (p99 $0.6363, success 100.0%, sample 20160) 7. Solana: $0.8588 (p99 $0.8711, success 100.0%, sample 20160) **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 //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 $111.4K (24h) on Hyperliquid HIP-3 deployer revenue leaderboard. **Rankings (p50, 24h):** 1. trade.xyz: $111.4K (p99 $0.2022, success 100.0%, sample 3449000) 2. Paragon: $636.22 (p99 $0.7056, success 100.0%, sample 65010) **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: Binance posts the lowest funding cost to hold a long 24h at 1.17 bps (p50, 24h) on Cheapest perp venue to hold a position, live funding normalized. **Rankings (p50, 24h):** 1. Binance: 1.17 bps (p99 -0.94 bps, success 100.0%, sample 2880) 2. Aster: 1.33 bps (p99 -1.01 bps, success 100.0%, sample 2880) 3. OKX: 1.46 bps (p99 -1.35 bps, success 100.0%, sample 2880) 4. Hyperliquid: 1.78 bps (p99 -0.72 bps, success 100.0%, sample 2880) 5. Paradex: 2.28 bps (p99 -0.39 bps, success 100.0%, sample 2880) 6. Polymarket: 3.00 bps (p99 1.41 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 51836.2) 2. Kalshi: 324 ms (p99 446 ms, success 100.0%, sample 51839.2) 3. Limitless: 332 ms (p99 947 ms, success 100.0%, sample 51838.2) 4. Manifold: 350 ms (p99 9.68 s, success 100.0%, sample 37030.6) 5. Myriad: 1.26 s (p99 2.33 s, success 100.0%, sample 51834.2) **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: Polymarket posts the lowest api latency (price endpoint) at 200 ms (p50, 24h) on Best prediction market API, ranked by live latency and uptime. **Rankings (p50, 24h):** 1. Polymarket: 200 ms (p99 250 ms, success 100.0%, sample 51837.2) 2. Kalshi: 326 ms (p99 400 ms, success 100.0%, sample 51838.2) 3. Manifold: 363 ms (p99 976 ms, success 100.0%, sample 37028.6) 4. Limitless: 365 ms (p99 1.05 s, success 100.0%, sample 51840.2) 5. Myriad: 1.26 s (p99 2.33 s, success 100.0%, sample 51834.2) **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 — Sports posts the lowest resolution delay at 5.7 min (p50, 24h) on Resolution delay, Polymarket vs Kalshi. **Rankings (p50, 24h):** 1. Kalshi — Sports: 5.7 min (p99 14.8 min, success 100.0%, sample 173) 2. Polymarket — Crypto: 10.4 min (p99 103.3 min, success 100.0%, sample 32789) 3. Kalshi — All: 13.0 min (p99 118.6 min, success 100.0%, sample 309) 4. Polymarket — Sports: 54.6 min (p99 237.9 min, success 100.0%, sample 495796) 5. Polymarket — All: 57.4 min (p99 238.9 min, success 100.0%, sample 697988) 6. Polymarket — Other: 150.4 min (p99 396.6 min, success 100.0%, sample 166802) 7. Polymarket — Politics: 182.4 min (p99 604.8 min, success 100.0%, sample 2601) **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: OpenSea leads field coverage at 95.8% (24h avg) on Best NFT collection metadata API: Moralis, Alchemy, OpenSea benchmarked. **Rankings (p50, 24h):** 1. OpenSea: 95.8% (p99 95.8%, success 100.0%, sample 4336.51) 2. Alchemy: 94.0% (p99 94.0%, success 100.0%, sample 6002.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 $5.70B (24h) on Perp DEX volume share, live 24h notional ranked. **Rankings (p50, 24h):** 1. Hyperliquid: $5.70B (p99 $7.06B, success 85.7%, sample 2880) 2. Aster: $1.81B (p99 $1.90B, success 85.7%, sample 2880) 3. Lighter: $1.33B (p99 $1.54B, success 85.7%, sample 2880) 4. Pacifica: $825.99M (p99 $838.68M, success 85.7%, sample 2880) 5. GRVT: $550.86M (p99 $585.15M, success 71.4%, sample 2880) 6. Extended: $544.44M (p99 $584.14M, success 85.7%, sample 2880) 7. Backpack: $290.34M (p99 $319.36M, success 50.0%, sample 2880) 8. Vertex: $141.95M (p99 $309.83M, success 85.7%, sample 2880) 9. Polymarket: $90.11M (p99 $101.57M, success 80.0%, sample 2880) 10. dYdX v4: $65.25M (p99 $110.22M, success 85.7%, sample 2880) 11. GMX V2: $61.51M (p99 $62.63M, success 66.7%, sample 2880) 12. Orderly: $51.90M (p99 $76.49M, success 50.0%, sample 2880) 13. Gains: $43.86M (p99 $43.86M, success 66.6%, sample 2880) 14. Aevo: $7.36M (p99 $8.65M, success 71.4%, sample 2880) 15. Paradex: $5.04M (p99 $5.74M, success 85.7%, 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: 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 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: Polymarket posts the lowest 24h eth funding stddev at 0.00021% (24h avg) on Perp DEX funding stability, 24h stddev of ETH funding ranked. **Rankings (p50, 24h):** 1. Polymarket: 0.00021% (p99 0.023%, success 100.0%, sample 2880) 2. Lighter: 0.0031% (p99 0.030%, success 100.0%, sample 2880) 3. Bitget: 0.0034% (p99 0.0089%, success 100.0%, sample 2880) 4. Coinbase: 0.0045% (p99 0.0072%, success 100.0%, sample 2880) 5. Gate: 0.0061% (p99 0.0080%, success 100.0%, sample 2880) 6. OKX: 0.0072% (p99 0.0073%, success 100.0%, sample 2880) 7. KuCoin: 0.0072% (p99 0.011%, success 100.0%, sample 2880) 8. Paradex: 0.0082% (p99 0.016%, success 100.0%, sample 2880) 9. MEXC: 0.0099% (p99 0.014%, success 100.0%, sample 2880) 10. Aster: 0.012% (p99 0.014%, success 100.0%, sample 2880) 11. Binance: 0.012% (p99 0.014%, success 100.0%, sample 2880) 12. Hyperliquid: 0.021% (p99 0.032%, success 100.0%, sample 2880) 13. Kraken: 0.022% (p99 0.080%, success 100.0%, sample 2880) 14. dYdX v4: 0.024% (p99 0.016%, 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 18 ms (p50, 24h) on Fastest free Ethereum RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 18 ms (p99 307 ms, success 95.4%, sample 4302.76) 2. PublicNode: 88 ms (p99 344 ms, success 99.8%, sample 4314.76) 3. NOWNodes: 185 ms (p99 337 ms, success 91.9%, sample 2157.84) 4. Nodies: 196 ms (p99 424 ms, success 100.0%, sample 4318.76) 5. Tenderly: 246 ms (p99 280 ms, success 99.7%, sample 4310.77) 6. MeowRPC: 264 ms (p99 624 ms, success 99.8%, sample 4315.76) **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":,"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 84 ms (p50, 24h) on Fastest free Arbitrum RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 84 ms (p99 280 ms, success 99.9%, sample 4312.76) 2. dRPC: 153 ms (p99 721 ms, success 94.6%, sample 4309.76) 3. Nodies: 192 ms (p99 374 ms, success 100.0%, sample 4317.76) 4. Tenderly: 240 ms (p99 256 ms, success 100.0%, sample 4314.76) 5. Arbitrum: 257 ms (p99 408 ms, success 100.0%, sample 4318.76) 6. MeowRPC: 274 ms (p99 478 ms, success 98.7%, sample 4315.76) **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":,"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 134 ms (p50, 24h) on Fastest free Base RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 134 ms (p99 494 ms, success 99.6%, sample 4308.79) 2. dRPC: 165 ms (p99 341 ms, success 78.9%, sample 4312.76) 3. Tenderly: 244 ms (p99 291 ms, success 100.0%, sample 4313.76) 4. Base: 260 ms (p99 425 ms, success 100.0%, sample 4319.76) 5. Nodies: 281 ms (p99 452 ms, success 100.0%, sample 4310.76) **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":,"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 85 ms (p50, 24h) on Fastest free Optimism RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 85 ms (p99 255 ms, success 100.0%, sample 4314.76) 2. dRPC: 166 ms (p99 288 ms, success 76.0%, sample 4319.76) 3. Tenderly: 240 ms (p99 256 ms, success 100.0%, sample 4313.76) 4. Nodies: 282 ms (p99 465 ms, success 100.0%, sample 4320.76) 5. Optimism: 341 ms (p99 426 ms, success 100.0%, sample 4320.76) **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":,"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 84 ms (p50, 24h) on Fastest free Avalanche RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 84 ms (p99 274 ms, success 100.0%, sample 4315.76) 2. dRPC: 198 ms (p99 440 ms, success 96.1%, sample 4309.76) 3. Avalanche: 200 ms (p99 251 ms, success 100.0%, sample 4318.76) 4. Tenderly: 241 ms (p99 271 ms, success 99.8%, sample 4314.76) **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":,"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 74 ms (p50, 24h) on Fastest free BNB Chain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Binance: 74 ms (p99 364 ms, success 100.0%, sample 4314.76) 2. PublicNode: 85 ms (p99 398 ms, success 99.7%, sample 4312.76) 3. NOWNodes: 239 ms (p99 650 ms, success 100.0%, sample 2165.83) **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":,"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 14 ms (p50, 24h) on Fastest free Polygon RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 14 ms (p99 299 ms, success 100.0%, sample 4301.76) 2. PublicNode: 86 ms (p99 395 ms, success 99.8%, sample 4320.76) 3. Tenderly: 242 ms (p99 262 ms, success 100.0%, sample 4307.76) **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":,"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 85 ms (p50, 24h) on Fastest free Linea RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 85 ms (p99 264 ms, success 100.0%, sample 4308.76) 2. dRPC: 256 ms (p99 476 ms, success 95.8%, sample 4311.76) 3. Tenderly: 327 ms (p99 406 ms, success 100.0%, sample 4319.76) **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":,"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 85 ms (p50, 24h) on Fastest free Scroll RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 85 ms (p99 262 ms, success 100.0%, sample 4315.76) 2. dRPC: 201 ms (p99 1.00 s, success 95.1%, sample 4312.77) 3. Tenderly: 327 ms (p99 372 ms, success 100.0%, sample 4317.76) **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":,"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 28 ms (p50, 24h) on Fastest free Mantle RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 28 ms (p99 1.35 s, success 95.6%, sample 4303.76) 2. PublicNode: 86 ms (p99 813 ms, success 100.0%, sample 4319.76) 3. Tenderly: 240 ms (p99 256 ms, success 100.0%, sample 4309.76) **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":,"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.16% (24h avg) on Best DEX for a $BOT market order, live slippage ranked. **Rankings (p50, 24h):** 1. Hyperliquid: 0.16% (p99 0.53%, success 100.0%, sample 2710) 2. Lighter: 1.27% (p99 2.88%, 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 85 ms (p50, 24h) on Fastest free Sonic RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 85 ms (p99 265 ms, success 100.0%, sample 4306.76) 2. dRPC: 189 ms (p99 386 ms, success 96.0%, sample 4304.76) 3. Sonic Labs: 219 ms (p99 273 ms, success 100.0%, sample 4320.76) 4. Tenderly: 241 ms (p99 256 ms, success 100.0%, sample 4306.76) **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":,"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 84 ms (p50, 24h) on Fastest free Gnosis RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 84 ms (p99 284 ms, success 100.0%, sample 4315.76) 2. dRPC: 168 ms (p99 273 ms, success 96.3%, sample 4316.76) 3. Tenderly: 240 ms (p99 255 ms, success 100.0%, sample 4314.76) 4. Gnosis: 340 ms (p99 1.32 s, success 100.0%, sample 4311.76) **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":,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal. - Archive depth: every 5 minutes we issue `eth_getBalance` at (head − depth) for depths from Geth's default pruned cap up to 5M blocks, exposing which free endpoints actually serve historical state. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, methodology and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to chain="gnosis". Provider coverage: 4 no-key endpoints (PublicNode, dRPC, Tenderly, Gnosis). Nodies was delisted 2026-07 when its Gnosis endpoint moved behind a paid plan. Exclusions follow the cluster-wide rules documented on the parent benchmark. ## Fastest free Celo RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/celo-rpc - JSON: https://openchainbench.com/api/stat/celo-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 96 ms (p50, 24h) on Fastest free Celo RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 96 ms (p99 594 ms, success 100.0%, sample 4313.76) 2. Celo (Forno): 199 ms (p99 441 ms, success 100.0%, sample 4315.76) 3. dRPC: 248 ms (p99 1.02 s, success 91.9%, sample 4314.76) 4. Tenderly: 329 ms (p99 360 ms, success 100.0%, sample 4310.76) **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":,"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":,"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 85 ms (p50, 24h) on Fastest free Unichain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 85 ms (p99 274 ms, success 100.0%, sample 4316.76) 2. dRPC: 169 ms (p99 711 ms, success 95.7%, sample 4303.75) 3. Tenderly: 240 ms (p99 257 ms, success 100.0%, sample 4311.76) 4. Unichain: 254 ms (p99 297 ms, success 100.0%, sample 4308.76) **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":,"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 4 ms, success 100.0%, sample 4309.76) 2. PublicNode: 86 ms (p99 285 ms, success 100.0%, sample 4307.76) 3. dRPC: 159 ms (p99 454 ms, success 95.7%, sample 4310.76) 4. Tenderly: 329 ms (p99 348 ms, success 100.0%, sample 4318.76) **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":,"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 89 ms (p50, 24h) on Fastest free Taiko RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 89 ms (p99 639 ms, success 100.0%, sample 4315.76) 2. Taiko: 217 ms (p99 2.18 s, success 100.0%, sample 4302.76) 3. dRPC: 238 ms (p99 323 ms, success 95.4%, sample 4317.76) 4. Tenderly: 329 ms (p99 361 ms, success 100.0%, sample 4313.76) **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":,"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: PublicNode posts the lowest rpc latency at 95 ms (p50, 24h) on Fastest free Berachain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 95 ms (p99 613 ms, success 100.0%, sample 4315.76) 2. Berachain: 157 ms (p99 189 ms, success 99.9%, sample 4315.77) 3. dRPC: 238 ms (p99 536 ms, success 93.8%, sample 4301.8) 4. Tenderly: 327 ms (p99 346 ms, success 100.0%, sample 4312.76) **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":,"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 170 ms (p50, 24h) on Fastest free zkSync Era RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 170 ms (p99 267 ms, success 95.8%, sample 4319.76) 2. zkSync: 219 ms (p99 860 ms, success 99.8%, sample 4312.76) 3. Tenderly: 330 ms (p99 381 ms, success 100.0%, sample 4318.76) **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":,"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 29 ms (p50, 24h) on Fastest free Cronos RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Cronos: 29 ms (p99 55 ms, success 94.2%, sample 4307.94) 2. PublicNode: 92 ms (p99 596 ms, success 100.0%, sample 4306.76) 3. dRPC: 168 ms (p99 279 ms, success 95.7%, sample 4303.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":,"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 29 ms (p50, 24h) on Fastest free Fraxtal RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Fraxtal: 29 ms (p99 205 ms, success 100.0%, sample 4316.76) 2. PublicNode: 94 ms (p99 644 ms, success 100.0%, sample 4317.76) 3. dRPC: 167 ms (p99 264 ms, success 95.8%, sample 4304.76) 4. Tenderly: 240 ms (p99 257 ms, success 100.0%, sample 4320.76) **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":,"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 18 ms (p50, 24h) on Fastest free Soneium RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Soneium: 18 ms (p99 63 ms, success 100.0%, sample 4307.76) 2. PublicNode: 88 ms (p99 230 ms, success 100.0%, sample 4317.76) 3. dRPC: 204 ms (p99 827 ms, success 91.1%, sample 4304.76) 4. Tenderly: 240 ms (p99 259 ms, success 100.0%, sample 4315.76) **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":,"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 3 ms (p50, 24h) on Fastest free Monad RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Monad: 3 ms (p99 5 ms, success 100.0%, sample 4307.76) 2. OnFinality: 148 ms (p99 2.22 s, success 100.0%, sample 4315.76) 3. dRPC: 190 ms (p99 299 ms, success 94.4%, sample 4309.76) 4. Tenderly Gateway: 241 ms (p99 272 ms, success 99.8%, sample 4315.76) **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":,"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 24 ms (p50, 24h) on Fastest free MegaETH RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. MegaETH Official: 24 ms (p99 63 ms, success 100.0%, sample 4315.76) 2. dRPC: 170 ms (p99 290 ms, success 96.0%, sample 4311.76) 3. Tenderly Gateway: 241 ms (p99 281 ms, success 99.8%, sample 4313.76) **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":,"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 20 ms, success 99.3%, sample 60462.4) 2. PancakeSwap MEV Guard: 22 ms (p99 33 ms, success 100.0%, sample 30231.1) 3. 48 Club Privacy RPC: 24 ms (p99 34 ms, success 100.0%, sample 30231.2) 4. MEV Blocker: 37 ms (p99 66 ms, success 99.9%, sample 30231.3) 5. Blink: 94 ms (p99 107 ms, success 96.9%, sample 90693.7) 6. Flashbots Protect: 101 ms (p99 113 ms, success 77.0%, sample 30239.3) 7. BlockSec Anti-MEV: 116 ms (p99 339 ms, success 100.0%, sample 60462.4) **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 22 ms (p50, 24h) on Fastest free Solana RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Solana: 22 ms (p99 749 ms, success 100.0%, sample 4315.76) 2. PublicNode: 86 ms (p99 757 ms, success 96.3%, sample 4305.77) 3. Solana Vibe Station: 194 ms (p99 603 ms, success 100.0%, sample 4317.76) 4. LeoRPC: 589 ms (p99 879 ms, success 99.6%, sample 4304.76) **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":,"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: AMD posts the lowest price deviation at 0.030% (24h avg) on Tokenized stock price accuracy, live onchain vs Nasdaq across 11 equities. **Rankings (p50, 24h):** 1. AMD: 0.030% (p99 1.11%, success 99.7%, sample 20160) 2. META: 0.27% (p99 0.43%, success 99.7%, sample 20160) 3. NVDA: 0.29% (p99 0.37%, success 99.7%, sample 20160) 4. PLTR: 0.49% (p99 1.09%, success 99.7%, sample 20160) 5. MU: 0.79% (p99 1.29%, success 99.7%, sample 20160) 6. AAPL: 1.04% (p99 1.43%, success 99.7%, sample 20160) **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 * Robinhood Token, shared verified Stock implementation) whose USDG pool has real liquidity and swap history: NVDA, AAPL, GOOGL, TSLA, PLTR, META, AMD, MSFT, AMZN, SPY, MU. Pool fees range 0.3% to 2%. - Excluded, with reasons: SPCX (SpaceX pool holds ~$196k but SpaceX is not listed, no reference price exists), SNDK and QQQ (pool depth under $2k, deviation would be noise), CRCL (pool at zero liquidity), ~80 other official tokens (issuer-seeded placeholder pools at 90-95% fee, zero swaps), HOOD (never issued onchain, all HOOD tokens on the chain are third-party spam). - Thin liquidity is part of the story, not a defect: pool depths run $24k to $330k, so a single mid-size swap can move the onchain price meaningfully off the reference until arbitrage closes it. The bench measures how fast that closure actually happens. - Reading grid: an AMM price can sit anywhere inside the pool's fee band without creating an arbitrage opportunity, so a 2% fee pool resting 150 bps off its reference is economically at equilibrium, not broken. Cross-symbol ranking therefore partly reflects each pool's fee tier (disclosed in every tag); the within-symbol trend over time is the purest signal. - Quote-asset caveat: pool prices are denominated in USDG and compared against USD references. A USDG peg wobble would appear as a correlated deviation across all 11 symbols simultaneously, which is the signature to check before reading a broad move as tracking error. - Caveats: the issuer can pause or blocklist a token (the harness drops the sample and lets the series age out rather than freezing), and the Stock contract carries a split multiplier; a corporate action can look like a one-day deviation spike until reconciled. ## xStocks price accuracy, live onchain vs Nasdaq across 12 equities on Solana - Category: RWA - Metric: Price deviation (bps) - Page: https://openchainbench.com/benchmarks/xstocks-peg - JSON: https://openchainbench.com/api/stat/xstocks-peg - Status: live - Headline: TSLAx posts the lowest price deviation at 0.052% (24h avg) on xStocks price accuracy, live onchain vs Nasdaq across 12 equities on Solana. **Rankings (p50, 24h):** 1. TSLAx: 0.052% (p99 0.10%, success 96.4%, sample 20160) 2. GOOGLx: 0.089% (p99 0.49%, success 96.6%, sample 20160) 3. NVDAx: 0.18% (p99 0.27%, success 99.7%, sample 20160) 4. HOODx: 0.19% (p99 0.92%, success 96.4%, sample 20160) 5. AMZNx: 0.19% (p99 0.28%, success 96.6%, sample 20160) 6. METAx: 0.20% (p99 0.50%, success 99.7%, sample 20160) 7. COINx: 0.22% (p99 0.32%, success 96.4%, sample 20160) 8. AAPLx: 0.25% (p99 0.61%, success 99.7%, sample 20160) 9. QQQx: 0.35% (p99 0.39%, success 96.4%, sample 20160) 10. MSFTx: 0.36% (p99 0.89%, success 96.4%, sample 20160) 11. PLTRx: 0.39% (p99 0.66%, success 99.7%, sample 20160) 12. SPYx: 0.62% (p99 0.68%, success 96.5%, sample 20160) **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.13% (24h avg) on USDY NAV basis, live market price vs official redemption rate. **Rankings (p50, 24h):** 1. Orca (Solana): 0.13% (p99 0.13%, success 0.0%, sample 20160) 2. Pyth market composite: 0.14% (p99 0.14%, success 0.0%, sample 20160) **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: NVDA posts the lowest weekend max drift at 0.92% (24h avg) on Tokenized stock weekend drift, how far each equity wanders Friday to Monday. **Rankings (p50, 24h):** 1. NVDA: 0.92% (p99 1.08%, success 99.7%, sample 20160) 2. META: 0.93% (p99 1.25%, success 99.7%, sample 20160) 3. AMD: 0.94% (p99 1.44%, success 99.7%, sample 20160) 4. AAPL: 0.96% (p99 1.00%, success 99.7%, sample 20160) 5. PLTR: 1.01% (p99 1.09%, success 99.7%, sample 20160) 6. MU: 1.35% (p99 4.05%, success 99.7%, sample 20160) **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 0.4 ms (p50, 24h) on Fastest Ethereum WebSocket newHeads push, live block-push lag across RPC providers. **Rankings (p50, 24h):** 1. PublicNode: 0.4 ms (p99 10.24 s, success 99.2%, sample 28434.6) 2. dRPC: 113 ms (p99 10.24 s, success 100.0%, sample 28659.7) 3. Tenderly: 224 ms (p99 10.24 s, success 94.6%, sample 27124.1) **Methodology**: - Providers measured (keyless WebSocket endpoints): PublicNode (wss://ethereum-rpc.publicnode.com), dRPC (wss://eth.drpc.org), Tenderly (wss://mainnet.gateway.tenderly.co), Onfinality (wss://eth.api.onfinality.io/public-ws). Keyed providers (Alchemy, Infura, Chainstack, QuickNode) join the cohort when contributor keys are wired via WS_URL__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: Tenderly posts the lowest reliability incidents at 1 (24h) on Most reliable free public RPC, correctness incidents across 7 EVM chains. **Rankings (p50, 24h):** 1. Tenderly: 1 (p99 0, success 99.8%, sample 496.111) 2. PublicNode: 12 (p99 74.8K, success 97.9%, sample 576.129) 3. Binance: 40 (p99 0, success 50.0%, sample 80.0179) 4. dRPC: 158 (p99 0.522, success 72.6%, sample 576.127) 5. Nodies: 164 (p99 0.250, success 67.1%, sample 498.111) **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 48.6% (24h avg) on Ethereum block builder market share. **Rankings (p50, 24h):** 1. Titan: 48.6% (p99 48.6%, success 100.0%, sample 3372.17) 2. Quasar: 20.0% (p99 20.0%, success 100.0%, sample 1384.48) 3. BuilderNet: 11.8% (p99 11.8%, success 100.0%, sample 816.283) 4. Vanilla: 8.26% (p99 8.26%, success 100.0%, sample 573.199) 5. Eureka: 6.57% (p99 6.57%, success 100.0%, sample 456.158) 6. Other: 3.47% (p99 3.47%, success 100.0%, sample 241.084) 7. Bob The Builder: 0.61% (p99 0.61%, success 100.0%, sample 42.0146) 8. Builder+: 0.49% (p99 0.49%, success 100.0%, sample 34.0118) 9. beaverbuild: 0.22% (p99 0.22%, success 100.0%, sample 15.0052) **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.09 s, success 100.0%, sample 4305.76) 2. PublicNode: 114 ms (p99 657 ms, success 100.0%, sample 4314.76) 3. Parity: 191 ms (p99 1.12 s, success 100.0%, sample 4306.76) **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":,"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.4 ms (p50, 24h) on Fastest Base WebSocket newHeads push, live block-push lag across RPC providers. **Rankings (p50, 24h):** 1. PublicNode: 0.4 ms (p99 148 ms, success 99.3%, sample 171299) 2. dRPC: 48 ms (p99 10.24 s, success 100.0%, sample 171299) **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__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.4 ms (p50, 24h) on Fastest Solana WebSocket slotSubscribe push, live slot-push lag across RPC providers. **Rankings (p50, 24h):** 1. Solana: 0.4 ms (p99 384 ms, success 76.7%, sample 790503) 2. PublicNode: 4 ms (p99 10.24 s, success 100.0%, sample 1057830) **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__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: USTB leads yield deviation at 0.24% (24h avg) on Which tokenized T-bill or yield fund actually pays what it promises. **Rankings (p50, 24h):** 1. USTB: 0.24% (p99 -3.52%, success 100.0%, sample 608825000) 2. SyrupUSDC: 0.010% (p99 -4.82%, success 100.0%, sample 974070000) **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 227 (24h) on DEX indexer with most blockchains, live coverage ranking. **Rankings (p50, 24h):** 1. GeckoTerminal: 227 (p99 227, success 100.0%, sample 227) 2. Codex: 123 (p99 123, success 100.0%, sample 123) 3. DexPaprika: 35 (p99 35, success 100.0%, sample 35) **Methodology**: - Source: each provider's public DEX-indexer networks endpoint. - GeckoTerminal: GET /api/v2/networks (paginated, no auth). Chains where GeckoTerminal actively indexes DEX pools + trades. - Codex: GraphQL `getNetworks` query at https://graph.codex.io/graphql with an official API key. Chains covered by Defined.fi's DEX data pipeline. - DexPaprika: GET https://api.dexpaprika.com/networks (no auth). CoinPaprika's dedicated DEX tracker product, separate from the market-data API. - Sim by Dune: GET https://api.sim.dune.com/v1/evm/supported-chains (no auth). EVM only, mainnets filtered via the `mainnet` tag. - Cadence: full refresh every 6 hours. - Counting: a provider's network is counted once per unique chain id or slug; mainnet only. - Failures (network errors, rate limits, auth errors) leave the previous count in place and increment a fetch_errors counter. the page falls back to its last successful sample. ## Fastest free Osmosis RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/osmosis-rpc - JSON: https://openchainbench.com/api/stat/osmosis-rpc - Status: live - Headline: Polkachu posts the lowest rpc latency at 186 ms (p50, 24h) on Fastest free Osmosis RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 186 ms (p99 360 ms, success 100.0%, sample 4306.76) 2. PublicNode: 194 ms (p99 618 ms, success 100.0%, sample 4306.76) 3. Osmosis Foundation: 199 ms (p99 1.73 s, success 99.9%, sample 4316.76) 4. LavenderFive: 214 ms (p99 366 ms, success 100.0%, sample 4304.76) 5. Imperator: 468 ms (p99 511 ms, success 68.7%, sample 4313.76) **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":,"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 15 ms (p50, 24h) on Fastest free Hyperliquid RPC, live no-key HyperEVM endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 15 ms (p99 95 ms, success 95.8%, sample 4311.76) 2. Hyperliquid Labs: 74 ms (p99 111 ms, success 97.4%, sample 4312.89) 3. Hypurrscan: 75 ms (p99 357 ms, success 99.9%, sample 4309.76) 4. Purroof Group: 176 ms (p99 232 ms, success 99.4%, sample 4314.76) 5. Stakely: 558 ms (p99 3.31 s, success 99.3%, sample 4304.76) **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":,"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 13 ms (p50, 24h) on Fastest free TRON RPC, live no-key JSON-RPC endpoint latency. **Rankings (p50, 24h):** 1. TronGrid: 13 ms (p99 58 ms, success 100.0%, sample 4319.76) 2. PublicNode: 155 ms (p99 520 ms, success 100.0%, sample 4308.76) **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":,"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: PublicNode posts the lowest rpc latency at 199 ms (p50, 24h) on Fastest free Cosmos Hub RPC, live no-key Cosmos SDK endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 199 ms (p99 648 ms, success 100.0%, sample 4318.76) 2. Polkachu: 202 ms (p99 386 ms, success 100.0%, sample 4319.76) 3. LavenderFive: 216 ms (p99 369 ms, success 100.0%, sample 4314.76) **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":,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 40 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="cosmos-hub"`. Provider coverage at launch: 4 no-key endpoints (PublicNode, Polkachu, LavenderFive, Lava Network). ## Fastest free Injective RPC, live no-key Cosmos SDK endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/injective-rpc - JSON: https://openchainbench.com/api/stat/injective-rpc - Status: live - Headline: Polkachu posts the lowest rpc latency at 207 ms (p50, 24h) on Fastest free Injective RPC, live no-key Cosmos SDK endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 207 ms (p99 412 ms, success 51.3%, sample 4311.42) 2. LavenderFive: 216 ms (p99 369 ms, success 100.0%, sample 4320.76) 3. Injective Foundation: 235 ms (p99 248 ms, success 100.0%, sample 4308.76) 4. PublicNode: 259 ms (p99 658 ms, success 100.0%, sample 4320.76) **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":,"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 205 ms (p50, 24h) on Fastest free Neutron RPC, live no-key Cosmos SDK endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 205 ms (p99 405 ms, success 100.0%, sample 4314.76) 2. LavenderFive: 214 ms (p99 359 ms, success 100.0%, sample 4310.76) **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":,"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 14 ms, success 100.0%, sample 4315.76) 2. Tenderly Gateway: 240 ms (p99 257 ms, success 100.0%, sample 4308.76) 3. dRPC: 377 ms (p99 1.81 s, success 89.1%, sample 4303.76) **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":,"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 75 ms (p50, 24h) on Fastest free Kaia RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Kaia Foundation: 75 ms (p99 131 ms, success 100.0%, sample 4316.76) **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":,"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 181 ms (p50, 24h) on Fastest free Ink RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. QuickNode: 181 ms (p99 207 ms, success 100.0%, sample 4318.76) 2. dRPC: 208 ms (p99 1.65 s, success 91.9%, sample 4304.76) 3. Gelato: 227 ms (p99 685 ms, success 100.0%, sample 4307.76) 4. Tenderly Gateway: 240 ms (p99 262 ms, success 100.0%, sample 4319.76) **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":,"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 4319.76) 2. dRPC: 100 ms (p99 813 ms, success 96.2%, sample 4315.76) 3. PublicNode: 238 ms (p99 421 ms, success 100.0%, sample 4317.76) **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":,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 25 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="opbnb"`. Provider coverage at launch: 3 no-key endpoints (BNB Chain Team, PublicNode, dRPC). ## Fastest Wormhole VAA finalization by source chain, live latency - Category: Bridges - Metric: VAA finalization (ms) - Page: https://openchainbench.com/benchmarks/wormhole-vaa-latency - JSON: https://openchainbench.com/api/stat/wormhole-vaa-latency - Status: live - Headline: Sui posts the lowest vaa finalization at 2.92 s (p50, 24h) on Fastest Wormhole VAA finalization by source chain, live latency. **Rankings (p50, 24h):** 1. Sui: 2.92 s (p99 9.35 s, success 100.0%, sample 382.133) 2. Monad: 3.68 s (p99 13.15 s, success 100.0%, sample 37.0129) 3. BNB Chain: 3.86 s (p99 13.58 s, success 100.0%, sample 993.345) 4. Avalanche: 4.33 s (p99 14.50 s, success 100.0%, sample 70.0243) 5. Polygon: 4.53 s (p99 14.13 s, success 100.0%, sample 157.055) 6. Ink: 7.50 s (p99 9.95 s, success 100.0%, sample 15.0052) 7. Solana: 12.59 s (p99 19.60 s, success 100.0%, sample 9267.22) 8. Ethereum: 15.3 min (p99 19.9 min, success 100.0%, sample 465.162) 9. Base: 15.3 min (p99 29.6 min, success 100.0%, sample 70.0243) 10. Arbitrum: 16.8 min (p99 28.9 min, success 100.0%, sample 22.0076) 11. Optimism: 17.5 min (p99 19.9 min, success 100.0%, sample 1.00035) 12. Unichain: 17.5 min (p99 19.9 min, success 100.0%, sample 2.00069) 13. Celo: 25.0 min (p99 29.9 min, success 100.0%, sample 2.00069) **Methodology**: - Data source: `https://api.wormholescan.io/api/v1/vaas?pageSize=100`, the public wormholescan indexer of Wormhole VAAs. Polled every 60 seconds. - Latency definition: `updatedAt − timestamp` from the VAA row. `timestamp` is the source-chain observation time (block containing the Wormhole message); `updatedAt` is the moment wormholescan first indexed the VAA as fully-signed by 13-of-19 Guardians. - Dedupe: last 10 000 VAA ids kept in memory (rolling FIFO). Wormholescan returns ~100 VAAs/min sustained; 10k cache holds ~100 minutes of history, well above any poll interval. - Bucketing: histogram with geometric buckets 2, 5, 10, 15, 20, 30, 45, 60, 90, 120, 180, 300, 600 seconds. - Guard: samples with `updatedAt − timestamp < 0` or `> 3600 s` are dropped (clock skew or backfilled VAAs whose `updatedAt` refers to a later re-index event). - No canary transactions: this bench observes organic Wormhole traffic (thousands of VAAs/day). No wallet is funded, no gas is paid. - Scope: 20 source chains Wormhole supports that are already tracked on OpenChainBench's chain registry. Chains with negligible VAA volume in a 24-hour window may appear with wide error bars or a low sample count. - Destination chain is not measured: VAAs are relayed on demand once quorum is reached, so post-quorum latency is caller-driven (relayer choice, destination gas price, etc.) and not a property of Wormhole itself. ## Best DEX aggregator for quoting newly-launched tokens - Category: Aggregators - Metric: Quote coverage (pct) - Page: https://openchainbench.com/benchmarks/token-quote-coverage - JSON: https://openchainbench.com/api/stat/token-quote-coverage - Status: live - Headline: Jupiter leads quote coverage at 95.0% (24h avg) on Best DEX aggregator for quoting newly-launched tokens. **Rankings (p50, 24h):** 1. Jupiter: 95.0% (p99 95.0%, success 95.0%, sample 1269.44) 2. KyberSwap: 93.7% (p99 93.7%, success 93.7%, sample 907.316) 3. Mobula: 88.3% (p99 88.3%, success 88.3%, sample 2176.76) **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 56.44 s (p50, 24h) on Fastest Chainlink CCIP source chain by end-to-end delivery latency. **Rankings (p50, 24h):** 1. Solana: 56.44 s (p99 2.0 min, success 100.0%, sample 104.036) 2. Avalanche: 1.0 min (p99 8.6 min, success 100.0%, sample 28.0094) 3. BNB Chain: 1.5 min (p99 4.8 min, success 100.0%, sample 139.048) 4. Monad: 1.5 min (p99 4.3 min, success 100.0%, sample 35.012) 5. Berachain: 4.0 min (p99 5.0 min, success 100.0%, sample 1.00035) 6. Polygon: 12.5 min (p99 14.9 min, success 100.0%, sample 7.00243) 7. Optimism: 16.7 min (p99 19.9 min, success 100.0%, sample 8.00278) 8. Ethereum: 17.0 min (p99 26.8 min, success 100.0%, sample 353.123) 9. Robinhood Chain: 17.7 min (p99 29.0 min, success 100.0%, sample 60.0208) 10. Arbitrum: 17.9 min (p99 29.4 min, success 100.0%, sample 30.0104) 11. Mantle: 21.3 min (p99 29.8 min, success 100.0%, sample 7.00243) 12. Ink: 23.7 min (p99 29.9 min, success 100.0%, sample 24.0083) 13. Base: 24.3 min (p99 32.9 min, success 100.0%, sample 142.049) 14. Unichain: 25.0 min (p99 29.9 min, success 100.0%, sample 1.00065) **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: Robinhood Chain posts the lowest layerzero delivery at 24.53 s (p50, 24h) on Fastest LayerZero source chain by end-to-end message delivery. **Rankings (p50, 24h):** 1. Robinhood Chain: 24.53 s (p99 1.8 min, success 100.0%, sample 697.242) 2. Arbitrum: 25.86 s (p99 27.7 min, success 100.0%, sample 1191.41) 3. BNB Chain: 28.32 s (p99 4.0 min, success 100.0%, sample 1495.52) 4. Monad: 31.50 s (p99 18.5 min, success 100.0%, sample 119.041) 5. Ink: 32.50 s (p99 4.7 min, success 100.0%, sample 13.0045) 6. Avalanche: 36.00 s (p99 3.2 min, success 100.0%, sample 88.0306) 7. Unichain: 41.00 s (p99 29.2 min, success 100.0%, sample 31.0108) 8. Solana: 41.59 s (p99 2.8 min, success 100.0%, sample 555.193) 9. Sui: 45.00 s (p99 59.70 s, success 100.0%, sample 4.00139) 10. Celo: 47.65 s (p99 4.4 min, success 100.0%, sample 30.0104) 11. Mantle: 1.0 min (p99 2.0 min, success 100.0%, sample 38.0132) 12. Base: 1.0 min (p99 3.3 min, success 100.0%, sample 1220.42) 13. Optimism: 1.1 min (p99 2.9 min, success 100.0%, sample 898.312) 14. Polygon: 1.7 min (p99 19.6 min, success 100.0%, sample 296.103) 15. Scroll: 2.8 min (p99 9.5 min, success 100.0%, sample 42.0146) 16. Linea: 3.5 min (p99 9.6 min, success 100.0%, sample 71.0247) 17. Ethereum: 4.1 min (p99 19.4 min, success 100.0%, sample 1264.44) **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.0 min, success 100.0%, sample 107.037) 2. Avalanche: 42.86 s (p99 8.7 min, success 100.0%, sample 26.009) 3. Osmosis: 46.88 s (p99 2.6 min, success 100.0%, sample 288.1) 4. Polygon: 47.81 s (p99 2.0 min, success 100.0%, sample 33.0115) 5. Ethereum: 16.9 min (p99 24.5 min, success 100.0%, sample 110.038) 6. Arbitrum: 19.7 min (p99 29.8 min, success 100.0%, sample 32.0111) 7. Celo: 25.0 min (p99 29.9 min, success 100.0%, sample 3.00104) 8. Base: 25.2 min (p99 37.0 min, success 100.0%, sample 59.0205) 9. Optimism: 26.7 min (p99 39.6 min, success 100.0%, sample 4.00139) **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 100 ms (p50, 24h) on Fastest free Sei RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Sei Labs: 100 ms (p99 140 ms, success 100.0%, sample 4314.76) 2. Stakeme: 223 ms (p99 606 ms, success 89.1%, sample 4307.82) **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":,"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 174 ms (p50, 24h) on Fastest free Mode RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Mode Labs: 174 ms (p99 195 ms, success 100.0%, sample 4317.76) 2. dRPC: 343 ms (p99 1.12 s, success 92.6%, sample 4310.76) **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":,"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 230 ms (p50, 24h) on Fastest free Ronin RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Sky Mavis: 230 ms (p99 457 ms, success 100.0%, sample 4313.76) 2. Tenderly Gateway: 240 ms (p99 260 ms, success 100.0%, sample 4306.76) **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":,"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 227 ms (p50, 24h) on Fastest free Immutable zkEVM RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Immutable: 227 ms (p99 262 ms, success 100.0%, sample 4321.76) 2. Tenderly Gateway: 327 ms (p99 349 ms, success 100.0%, sample 4306.76) 3. dRPC: 348 ms (p99 1.01 s, success 95.3%, sample 4315.76) **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":,"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 1.96 s (p50, 24h) on Polymarket WebSocket latency, live connection and update speed from 3 regions. **Rankings (p50, 24h):** 1. Polymarket: 1.96 s (p99 3.77 s, success 50.0%, sample 15.0045) 2. Kalshi: 5.0 min (p99 5.0 min, success 50.0%, sample 3.00112) **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: HyperStake leads net yield at 2.23% (24h avg) on Hyperliquid validator leaderboard: live net APR, uptime, commission. **Rankings (p50, 24h):** 1. HyperStake: 2.23% (p99 2.23%, success 100.0%, sample 791635000) 2. CMI: 2.23% (p99 2.23%, success 100.0%, sample 770161000) 3. Flowdex: 2.23% (p99 2.23%, success 100.0%, sample 328152000) 4. Hypurrscanning: 2.21% (p99 2.21%, success 100.0%, sample 1954800000) 5. Alphaticks: 2.21% (p99 2.21%, success 100.0%, sample 398839000) 6. Asymmetric Research: 2.20% (p99 2.20%, success 100.0%, sample 287459000) 7. Purrposeful x HyBridge x PiP: 2.20% (p99 2.20%, success 100.0%, sample 595543000) 8. Hyperliquid Strategies x Unit: 2.19% (p99 2.19%, success 100.0%, sample 2294300000) 9. Nansen x HypurrCollective: 2.19% (p99 2.19%, success 100.0%, sample 1876840000) 10. Hyperbeat x P2P x Hypio: 2.19% (p99 2.19%, success 100.0%, sample 339777000) 11. Bitwise Onchain Solutions x FalconX: 2.18% (p99 2.18%, success 100.0%, sample 319033000) 12. Hyper Foundation 3: 2.17% (p99 2.17%, success 100.0%, sample 4673390000) 13. Hyper Foundation 2: 2.17% (p99 2.17%, success 100.0%, sample 4555510000) 14. Hyper Foundation 1: 2.17% (p99 2.17%, success 100.0%, sample 4415740000) 15. Hyper Foundation 4: 2.17% (p99 2.17%, success 100.0%, sample 2906140000) 16. Hyper Foundation 5: 2.17% (p99 2.17%, success 100.0%, sample 1284290000) 17. Hyperdash: 2.17% (p99 2.17%, success 100.0%, sample 806640000) 18. HypurrCorea - Spacebar x DeSpread: 2.17% (p99 2.17%, success 100.0%, sample 692491000) 19. USDT0 x Luganodes: 2.17% (p99 2.17%, success 100.0%, sample 715408000) 20. Liquid Spirit x Hydromancer x Rekt Gang: 2.17% (p99 2.17%, success 100.0%, sample 379623000) 21. Enigma - Hypedexer.com X Meria: 2.17% (p99 2.17%, success 100.0%, sample 299692000) 22. Kinetiq x Hyperion: 2.15% (p99 2.15%, success 100.0%, sample 550241000) 23. ValiDAO: 2.15% (p99 2.15%, success 100.0%, sample 545442000) 24. infinitefield.xyz: 2.14% (p99 2.14%, success 98.8%, sample 1476500000) 25. ASXN: 2.13% (p99 2.13%, success 100.0%, sample 731789000) 26. B-Harvest: 2.12% (p99 2.12%, success 100.0%, sample 433435000) 27. Anchorage By Figment: 2.01% (p99 2.01%, success 100.0%, sample 2555050000) **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. Hyperliquid 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 573 (24h) on Most tradable markets on a perp DEX, live count across 14 venues. **Rankings (p50, 24h):** 1. Aster: 573 (p99 574, success 85.7%, sample 2880) 2. Gains: 360 (p99 360, success 66.6%, sample 2880) 3. Extended: 321 (p99 323, success 85.7%, sample 2880) 4. edgeX: 292 (p99 292, success 54.9%, sample 2880) 5. Aevo: 234 (p99 234, success 71.4%, sample 2880) 6. Lighter: 216 (p99 216, success 85.7%, sample 2880) 7. GRVT: 194 (p99 194, success 71.4%, sample 2880) 8. Hyperliquid: 178 (p99 178, success 85.7%, sample 2880) 9. Ostium: 83 (p99 83, success 83.3%, sample 2880) 10. dYdX v4: 78 (p99 78, success 85.7%, sample 2880) 11. Pacifica: 77 (p99 77, success 85.7%, sample 2880) 12. Vertex: 72 (p99 72, success 85.7%, sample 2880) 13. Polymarket: 67 (p99 67, success 80.0%, sample 2880) 14. Paradex: 63 (p99 63, success 85.7%, 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: 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 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: 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.126x (p99 1.008x, success 100.0%, sample 2880) 4. Aster: 1.150x (p99 1.009x, success 100.0%, sample 2880) 5. Extended: 1.260x (p99 1.008x, success 100.0%, sample 2880) 6. dYdX v4: 1.833x (p99 1.115x, success 100.0%, sample 2880) 7. Lighter: 6.96x (p99 1.536x, success 100.0%, sample 2880) **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, 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: Paradex posts the lowest mark price deviation at 0.015% (24h avg) on Perp DEX mark price fidelity: deviation from CEX spot reference, live. **Rankings (p50, 24h):** 1. Paradex: 0.015% (p99 0.055%, success 100.0%, sample 2880) 2. dYdX v4: 0.022% (p99 0.077%, success 100.0%, sample 2880) 3. Lighter: 0.037% (p99 0.060%, success 100.0%, sample 2880) 4. Hyperliquid: 0.039% (p99 0.073%, 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 (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 leads days since last exploit at 1,744 (24h) on Perp DEX security track record: days without a recorded exploit, live. **Rankings (p50, 24h):** 1. Gains: 1,744 (p99 1,744, success 100.0%, sample 2880) 2. Lighter: 1,167 (p99 1,167, success 100.0%, sample 2880) 3. dYdX v4: 1,075 (p99 1,075, success 100.0%, sample 2880) 4. Paradex: 1,075 (p99 1,075, success 100.0%, sample 2880) 5. Hyperliquid: 1,044 (p99 1,044, success 100.0%, sample 2880) 6. GMX v2: 428 (p99 428, 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: 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 22 ms (p50, 24h) on Fastest free Kava RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 22 ms (p99 377 ms, success 100.0%, sample 4313.76) 2. PublicNode: 87 ms (p99 502 ms, success 100.0%, sample 4309.76) 3. Kava Labs: 241 ms (p99 970 ms, success 100.0%, sample 4319.76) 4. dRPC: 247 ms (p99 467 ms, success 95.8%, sample 4301.76) **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":,"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 178 ms (p50, 24h) on Fastest free Zora RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Zora Network: 178 ms (p99 214 ms, success 100.0%, sample 4318.76) 2. Conduit: 180 ms (p99 309 ms, success 100.0%, sample 4317.76) 3. dRPC: 333 ms (p99 582 ms, success 95.6%, sample 4310.76) **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":,"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 and Lighter; native venue APIs for others. - Gains: 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 330 ms (p50, 24h) on Fastest free Abstract RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Abstract Foundation: 330 ms (p99 1.32 s, success 100.0%, sample 4313.76) 2. dRPC: 348 ms (p99 1.11 s, success 80.8%, sample 4312.76) **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":,"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 214 ms (p50, 24h) on Fastest free ApeChain RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. ApeChain: 214 ms (p99 472 ms, success 100.0%, sample 4309.76) 2. dRPC: 240 ms (p99 606 ms, success 94.8%, sample 4310.76) 3. Tenderly: 327 ms (p99 416 ms, success 100.0%, sample 4313.76) **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":,"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 171 ms, success 98.6%, sample 4313.76) 2. Tenderly: 240 ms (p99 256 ms, success 100.0%, sample 4315.76) 3. Lisk: 330 ms (p99 1.35 s, success 100.0%, sample 4313.76) **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":,"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: dRPC posts the lowest rpc latency at 176 ms (p50, 24h) on Fastest free Swellchain RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 176 ms (p99 251 ms, success 94.4%, sample 4305.83) **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":,"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 202 ms, success 100.0%, sample 4318.76) 2. AltLayer: 179 ms (p99 409 ms, success 100.0%, sample 4317.76) **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":,"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 189 ms (p50, 24h) on Fastest free Rootstock RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Rootstock Foundation: 189 ms (p99 868 ms, success 100.0%, sample 4316.76) 2. dRPC: 302 ms (p99 1.53 s, success 71.0%, sample 4312.76) **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":,"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 86 ms (p50, 24h) on Fastest free Metis RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 86 ms (p99 627 ms, success 100.0%, sample 4319.76) 2. dRPC: 236 ms (p99 316 ms, success 95.6%, sample 4304.76) 3. Metis: 252 ms (p99 827 ms, success 100.0%, sample 4306.76) **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":,"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 201 ms (p50, 24h) on Fastest free Manta Pacific RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Manta Network: 201 ms (p99 226 ms, success 100.0%, sample 4307.76) 2. dRPC: 223 ms (p99 1.49 s, success 82.3%, sample 4316.76) **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":,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="manta"`. Provider coverage: 4 no-key endpoints. ## Fastest free Story RPC, live no-key EVM endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/story-rpc - JSON: https://openchainbench.com/api/stat/story-rpc - Status: live - Headline: Ankr posts the lowest rpc latency at 72 ms (p50, 24h) on Fastest free Story RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 72 ms (p99 157 ms, success 100.0%, sample 4319.76) 2. Story Foundation: 81 ms (p99 118 ms, success 100.0%, sample 4311.76) 3. PublicNode: 98 ms (p99 665 ms, success 100.0%, sample 4311.76) 4. Stakely: 418 ms (p99 3.18 s, success 98.9%, sample 4304.76) **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":,"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 97 ms (p50, 24h) on Fastest free Morph RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Morph: 97 ms (p99 435 ms, success 99.9%, sample 4309.76) 2. QuickNode: 156 ms (p99 173 ms, success 83.4%, sample 4320.8) 3. dRPC: 259 ms (p99 395 ms, success 96.2%, sample 4310.76) **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":,"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":,"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 250 ms, success 95.7%, sample 4305.76) 2. Hemi Labs: 294 ms (p99 419 ms, success 100.0%, sample 4320.76) **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":,"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 177 ms (p50, 24h) on Fastest free BOB RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. BOB: 177 ms (p99 204 ms, success 100.0%, sample 4306.76) 2. Tenderly: 327 ms (p99 355 ms, success 100.0%, sample 4314.76) 3. dRPC: 336 ms (p99 804 ms, success 95.4%, sample 4306.76) **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":,"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 317 ms (p50, 24h) on Fastest free Polygon zkEVM RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Polygon zkEVM: 317 ms (p99 343 ms, success 100.0%, sample 4314.76) 2. dRPC: 334 ms (p99 550 ms, success 95.7%, sample 4301.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":,"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 87 ms (p50, 24h) on Fastest free Arbitrum Nova RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 87 ms (p99 609 ms, success 100.0%, sample 4315.76) 2. dRPC: 221 ms (p99 599 ms, success 96.3%, sample 4311.76) **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":,"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 104 ms, success 100.0%, sample 4315.76) 2. dRPC: 166 ms (p99 280 ms, success 95.9%, sample 4315.76) **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":,"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 44 ms (p50, 24h) on Fastest free Flare RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 44 ms (p99 387 ms, success 100.0%, sample 4315.76) 2. dRPC: 237 ms (p99 323 ms, success 96.3%, sample 4317.76) 3. Flare Foundation: 316 ms (p99 1.28 s, success 99.9%, sample 4302.76) **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":,"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 30 ms (p50, 24h) on Fastest free Core Chain RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 30 ms (p99 336 ms, success 100.0%, sample 4313.76) 2. dRPC: 170 ms (p99 264 ms, success 96.0%, sample 4312.76) 3. Core DAO: 255 ms (p99 753 ms, success 100.0%, sample 4318.76) **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":,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result with a parsable hex block number), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. Latency without reliability is a misleading ranking signal. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="core"`. Provider coverage: 4 no-key endpoints. ## Fastest free Fuse Network RPC, live no-key EVM endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/fuse-rpc - JSON: https://openchainbench.com/api/stat/fuse-rpc - Status: live - Headline: dRPC posts the lowest rpc latency at 193 ms (p50, 24h) on Fastest free Fuse Network RPC, live no-key EVM endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 193 ms (p99 420 ms, success 95.9%, sample 4304.76) 2. Fuse Foundation: 211 ms (p99 244 ms, success 100.0%, sample 4314.76) **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":,"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 leads markets per $m tvl at 35 (24h) on Perp DEX capital efficiency: active markets per $M TVL, live. **Rankings (p50, 24h):** 1. Gains: 35 (p99 35, success 66.6%, sample 2880) 2. Ostium: 6 (p99 6, success 83.3%, sample 2880) 3. dYdX v4: 0.722 (p99 0.722, success 85.7%, sample 2880) 4. Hyperliquid: 0.026 (p99 0.026, 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: 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 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 7 ms (p50, 24h) on Fastest free Filecoin RPC, live no-key FEVM endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 7 ms (p99 45 ms, success 100.0%, sample 4320.76) 2. Glif: 251 ms (p99 755 ms, success 100.0%, sample 4321.76) 3. dRPC: 293 ms (p99 809 ms, success 95.5%, sample 4304.76) **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":,"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 185 ms (p50, 24h) on Fastest free Canto RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Canto Official: 185 ms (p99 542 ms, success 100.0%, sample 4314.76) **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":,"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 227 ms (p50, 24h) on Fastest free Aurora RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Aurora Labs: 227 ms (p99 1.57 s, success 99.9%, sample 4311.76) **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":,"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 16 ms (p50, 24h) on Fastest free Bitlayer RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Bitlayer Official: 16 ms (p99 41 ms, success 99.9%, sample 4317.76) 2. dRPC: 381 ms (p99 700 ms, success 95.4%, sample 4315.76) **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":,"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: B² Network Official posts the lowest rpc latency at 188 ms (p50, 24h) on Fastest free B² Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. B² Network Official: 188 ms (p99 900 ms, success 100.0%, sample 4309.76) 2. dRPC: 347 ms (p99 717 ms, success 95.3%, sample 4312.76) **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":,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms → 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err` (HTTP 200 carrying an error body), `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="b2"`. Provider coverage at launch: 3 no-key endpoints (B² Official, dRPC, Thirdweb). ## Fastest free dYdX Chain RPC, live no-key Cosmos SDK endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/dydx-rpc - JSON: https://openchainbench.com/api/stat/dydx-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 136 ms (p50, 24h) on Fastest free dYdX Chain RPC, live no-key Cosmos SDK endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 136 ms (p99 619 ms, success 100.0%, sample 4311.76) 2. Polkachu: 191 ms (p99 380 ms, success 100.0%, sample 4315.76) 3. LavenderFive: 215 ms (p99 367 ms, success 99.7%, sample 4311.76) **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":,"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 206 ms (p50, 24h) on Fastest free Celestia RPC, live no-key Cosmos SDK endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 206 ms (p99 405 ms, success 100.0%, sample 4309.76) 2. LavenderFive: 219 ms (p99 371 ms, success 100.0%, sample 4315.76) 3. PublicNode: 268 ms (p99 667 ms, success 100.0%, sample 4320.76) **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":,"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 251 ms (p50, 24h) on Fastest free Boba Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Boba Foundation: 251 ms (p99 981 ms, success 100.0%, sample 4306.76) 2. dRPC: 287 ms (p99 469 ms, success 95.4%, sample 4312.76) **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":,"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 7 ms (p50, 24h) on Fastest free XDC Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 7 ms (p99 75 ms, success 100.0%, sample 4319.76) 2. XDC eRPC: 206 ms (p99 545 ms, success 98.8%, sample 4307.77) **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":,"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 59 ms (p50, 24h) on Fastest free Astar Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. OnFinality: 59 ms (p99 2.21 s, success 100.0%, sample 4308.76) **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":,"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 243 ms (p50, 24h) on Fastest free Oasis Sapphire RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Oasis Foundation: 243 ms (p99 447 ms, success 100.0%, sample 4317.76) **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":,"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 262 ms (p50, 24h) on Fastest free Oasis Emerald RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Oasis Foundation: 262 ms (p99 812 ms, success 100.0%, sample 4306.76) **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":,"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 141 ms (p50, 24h) on Fastest free Conflux eSpace RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Conflux Foundation: 141 ms (p99 380 ms, success 100.0%, sample 4314.76) 2. Conflux Global: 255 ms (p99 586 ms, success 99.9%, sample 4308.76) **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":,"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 189 ms (p50, 24h) on Fastest free IoTeX RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. IoTeX Mirror: 189 ms (p99 361 ms, success 100.0%, sample 4321.76) **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":,"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 165 ms (p50, 24h) on Fastest free Harmony ONE RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Harmony S0: 165 ms (p99 494 ms, success 98.9%, sample 4319.77) **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":,"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 177 ms (p50, 24h) on Fastest free Zircuit RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Zircuit Foundation: 177 ms (p99 202 ms, success 100.0%, sample 4311.76) **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":,"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 323 ms (p50, 24h) on Fastest free Plume Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 323 ms (p99 518 ms, success 93.8%, sample 4309.76) **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":,"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 158 ms (p50, 24h) on Fastest free Vana RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Vana Foundation: 158 ms (p99 172 ms, success 100.0%, sample 4310.76) **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":,"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: Gravity Foundation posts the lowest rpc latency at 177 ms (p50, 24h) on Fastest free Gravity Alpha RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Gravity Foundation: 177 ms (p99 197 ms, success 100.0%, sample 4310.76) **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":,"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 338 ms (p50, 24h) on Fastest free Reya Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Reya Foundation: 338 ms (p99 421 ms, success 100.0%, sample 4307.76) **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":,"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: PublicNode posts the lowest rpc latency at 152 ms (p50, 24h) on Fastest free Akash Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 152 ms (p99 690 ms, success 100.0%, sample 4314.76) 2. Polkachu: 205 ms (p99 403 ms, success 100.0%, sample 4310.76) 3. Ecostake: 241 ms (p99 552 ms, success 100.0%, sample 4306.76) **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":,"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 209 ms (p50, 24h) on Fastest free Stride RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 209 ms (p99 412 ms, success 100.0%, sample 4306.76) 2. LavenderFive: 215 ms (p99 423 ms, success 100.0%, sample 4319.76) **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":,"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: PublicNode posts the lowest rpc latency at 122 ms (p50, 24h) on Fastest free Juno RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 122 ms (p99 644 ms, success 100.0%, sample 4315.76) 2. Polkachu: 204 ms (p99 390 ms, success 100.0%, sample 4306.76) **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":,"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 189 ms (p50, 24h) on Fastest free Axelar RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 189 ms (p99 377 ms, success 100.0%, sample 4305.76) 2. PublicNode: 192 ms (p99 727 ms, success 100.0%, sample 4307.76) 3. LavenderFive: 215 ms (p99 365 ms, success 100.0%, sample 4314.76) **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":,"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 203 ms (p50, 24h) on Fastest free Dymension RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 203 ms (p99 403 ms, success 100.0%, sample 4320.76) 2. LavenderFive: 213 ms (p99 357 ms, success 100.0%, sample 4311.76) **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":,"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 206 ms (p50, 24h) on Fastest free Persistence RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 206 ms (p99 404 ms, success 100.0%, sample 4306.76) 2. Persistence Foundation: 263 ms (p99 803 ms, success 100.0%, sample 4313.76) **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":,"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 110 ms (p50, 24h) on Fastest free Coreum RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 110 ms (p99 718 ms, success 100.0%, sample 4315.76) 2. NOWNodes: 218 ms (p99 377 ms, success 100.0%, sample 1359.83) 3. Coreum Foundation: 648 ms (p99 785 ms, success 100.0%, sample 4313.76) **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":,"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 205 ms (p50, 24h) on Fastest free Nolus RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 205 ms (p99 402 ms, success 100.0%, sample 4306.76) **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":,"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: Archway Foundation posts the lowest rpc latency at 206 ms (p50, 24h) on Fastest free Archway RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Archway Foundation: 206 ms (p99 277 ms, success 100.0%, sample 4318.76) 2. Polkachu: 206 ms (p99 408 ms, success 100.0%, sample 4317.76) 3. LavenderFive: 242 ms (p99 359 ms, success 100.0%, sample 4316.76) **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":,"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 169 ms (p50, 24h) on Fastest free Nibiru RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Nibiru Foundation: 169 ms (p99 541 ms, success 100.0%, sample 4311.76) 2. Polkachu: 205 ms (p99 405 ms, success 100.0%, sample 4320.76) **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":,"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 204 ms (p50, 24h) on Fastest free Quicksilver RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 204 ms (p99 204 ms, success 0.0%, sample 4317.5) 2. Quicksilver Foundation: 247 ms (p99 1.21 s, success 16.3%, sample 4310.88) **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":,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result with a parsable decimal `sync_info.latest_block_height`), `http_err`, `jsonrpc_err`, `stale` (more than 40 blocks behind the cross-provider tip), `timeout`. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="quicksilver"`. Provider coverage at launch: 3 no-key endpoints (Polkachu, PublicNode, Quicksilver Foundation). ## Fastest free Terra RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/terra-rpc - JSON: https://openchainbench.com/api/stat/terra-rpc - Status: live - Headline: LavenderFive posts the lowest rpc latency at 195 ms (p50, 24h) on Fastest free Terra RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. LavenderFive: 195 ms (p99 325 ms, success 100.0%, sample 4320.76) 2. Polkachu: 205 ms (p99 403 ms, success 100.0%, sample 4320.76) 3. PublicNode: 483 ms (p99 755 ms, success 100.0%, sample 4315.76) **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":,"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 205 ms (p50, 24h) on Fastest free Regen Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 205 ms (p99 403 ms, success 100.0%, sample 4310.76) **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":,"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 220 ms (p50, 24h) on Fastest free Comdex RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. STAVR: 220 ms (p99 348 ms, success 100.0%, sample 4313.76) **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":,"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 219 ms (p50, 24h) on Fastest free Fantom RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Fantom Foundation: 219 ms (p99 286 ms, success 100.0%, sample 4313.76) 2. dRPC: 258 ms (p99 380 ms, success 95.5%, sample 4309.76) **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":,"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.32 s, success 100.0%, sample 4314.76) 2. PublicNode: 143 ms (p99 658 ms, success 100.0%, sample 4316.76) 3. dRPC: 744 ms (p99 1.19 s, success 94.0%, sample 4316.76) **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":,"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 19 ms (p50, 24h) on Fastest free Hydration RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Hydration: 19 ms (p99 591 ms, success 100.0%, sample 4308.76) 2. Dwellir: 335 ms (p99 524 ms, success 100.0%, sample 4315.76) **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":,"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 676 ms (p50, 24h) on Fastest free ZetaChain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Thirdweb: 676 ms (p99 807 ms, success 1.4%, sample 4309.76) **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":,"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 88 ms (p50, 24h) on Fastest free HAQQ Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 88 ms (p99 622 ms, success 100.0%, sample 4317.76) 2. HAQQ Foundation: 182 ms (p99 560 ms, success 100.0%, sample 4311.76) 3. dRPC: 223 ms (p99 680 ms, success 95.4%, sample 4302.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":,"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 50 ms, success 100.0%, sample 4313.76) 2. dRPC: 210 ms (p99 411 ms, success 95.3%, sample 4315.76) **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":,"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 88 ms (p50, 24h) on Fastest free Chiliz Chain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 88 ms (p99 318 ms, success 100.0%, sample 4315.76) 2. Chiliz Foundation: 172 ms (p99 655 ms, success 100.0%, sample 4306.76) 3. Ankr: 195 ms (p99 403 ms, success 100.0%, sample 4319.76) **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":,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. - Latency: client-side round-trip delta in milliseconds, exposed as both a gauge and a histogram (buckets 50 ms to 10 s), so percentiles are computed via Prometheus `quantile_over_time` over the last 24 hours. - Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err`, `jsonrpc_err`, `stale` (more than 20 blocks behind the cross-provider tip), `timeout`. - This page is part of the per-chain RPC cluster derived from the cross-chain [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities) benchmark; the identical harness, cadence and exclusion rules apply on every chain. - Chain scope: every query on this page is pinned to `chain="chiliz"`. Provider coverage at launch: 4 no-key endpoints. ## Fastest free WEMIX RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/wemix-rpc - JSON: https://openchainbench.com/api/stat/wemix-rpc - Status: live - Headline: dRPC posts the lowest rpc latency at 169 ms (p50, 24h) on Fastest free WEMIX RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 169 ms (p99 295 ms, success 95.3%, sample 4315.76) **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":,"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 316 ms (p50, 24h) on Fastest free Songbird RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Flare Foundation: 316 ms (p99 1.28 s, success 99.7%, sample 4318.76) **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":,"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 237 ms (p50, 24h) on Fastest free Cronos zkEVM RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Cronos (Crypto.com): 237 ms (p99 666 ms, success 100.0%, sample 4312.76) 2. dRPC: 327 ms (p99 716 ms, success 95.4%, sample 4303.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":,"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 291 ms (p50, 24h) on Fastest free Ethereum Classic RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 291 ms (p99 524 ms, success 95.8%, sample 4303.76) **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":,"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 202 ms (p50, 24h) on Fastest free Telos EVM RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 202 ms (p99 466 ms, success 95.6%, sample 4305.76) **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":,"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 85 ms (p50, 24h) on Fastest free PulseChain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 85 ms (p99 236 ms, success 100.0%, sample 4315.76) 2. G4MM4: 209 ms (p99 682 ms, success 100.0%, sample 4305.76) 3. PulseChain Foundation: 210 ms (p99 538 ms, success 100.0%, sample 4315.76) **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":,"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: PublicNode posts the lowest rpc latency at 106 ms (p50, 24h) on Fastest free Warden Protocol RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 106 ms (p99 730 ms, success 100.0%, sample 4308.76) 2. Warden Foundation: 189 ms (p99 531 ms, success 100.0%, sample 4314.76) **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":,"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: PublicNode posts the lowest rpc latency at 152 ms (p50, 24h) on Fastest free Oraichain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 152 ms (p99 647 ms, success 100.0%, sample 4316.76) 2. Orai Foundation: 207 ms (p99 408 ms, success 100.0%, sample 4314.76) **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 56 ms (p50, 24h) on Fastest free Peaq Network RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. OnFinality: 56 ms (p99 2.12 s, success 100.0%, sample 4311.76) 2. PublicNode: 96 ms (p99 351 ms, success 100.0%, sample 4306.76) **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":,"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 $111.69M (24h) on Solana meme launchpad leaderboard: PumpFun vs Flap vs Bankr, live 24h volume. **Rankings (p50, 24h):** 1. PumpFun: $111.69M (p99 $111.69M, success 100.0%, sample 2936550) 2. Raydium Launchlab: $26.48M (p99 $26.48M, success 100.0%, sample 411821) 3. Flap: $25.62M (p99 $25.62M, success 100.0%, sample 329921) 4. Meteora DBC: $10.66M (p99 $10.66M, success 100.0%, sample 647348) 5. NOXA Fun: $9.06M (p99 $9.06M, success 100.0%, sample 34485) 6. Bankr: $4.90M (p99 $4.90M, success 100.0%, sample 37625) 7. LetsCash: $2.18M (p99 $2.18M, success 100.0%, sample 6056) 8. dontblink: $594.6K (p99 $594.6K, success 100.0%, sample 1547) **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 $112.66M (24h) on Trading platform leaderboard: GMGN vs Axiom vs Fomo vs pump.fun, live 24h volume. **Rankings (p50, 24h):** 1. GMGN: $112.66M (p99 $112.66M, success 100.0%, sample 112658000) 2. Axiom: $90.70M (p99 $90.70M, success 100.0%, sample 90698800) 3. Fomo: $52.14M (p99 $52.14M, success 100.0%, sample 52141100) 4. pump.fun: $28.63M (p99 $28.63M, success 100.0%, sample 28628300) 5. BasedBot: $23.52M (p99 $23.52M, success 100.0%, sample 23520100) 6. Terminal: $16.13M (p99 $16.13M, success 100.0%, sample 16132100) 7. Trojan: $4.74M (p99 $4.74M, success 100.0%, sample 4735530) 8. Photon: $2.42M (p99 $2.42M, success 100.0%, sample 2423470) **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.80x (p50, 24h) on Crypto trading app iOS App Store ratings, live. **Rankings (p50, 24h):** 1. Fomo: 4.80x (p99 4.80x, success 100.0%, sample 16950) 2. Kraken: 4.74x (p99 4.74x, success 100.0%, sample 34731) 3. PumpFun: 4.73x (p99 4.73x, success 100.0%, sample 3079) 4. Bybit: 4.69x (p99 4.69x, success 100.0%, sample 46900) 5. Coinbase: 4.68x (p99 4.68x, success 100.0%, sample 1797240) 6. Crypto.com: 4.66x (p99 4.66x, success 100.0%, sample 333864) 7. Robinhood: 4.29x (p99 4.29x, success 100.0%, sample 4828740) 8. Invo: 4.23x (p99 4.23x, success 100.0%, sample 452) 9. Moonshot: 4.22x (p99 4.22x, success 100.0%, sample 28696) 10. Binance.US: 4.21x (p99 4.21x, success 100.0%, sample 111040) 11. GMGN: 3.69x (p99 3.69x, success 100.0%, sample 87) **Methodology**: - Source: Apple iTunes public lookup API (itunes.apple.com/lookup?id=&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.54% (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.54% (p99 0.54%, success 100.0%, sample 126373) 2. Fomo: 0.71% (p99 0.71%, success 100.0%, sample 368583) 3. GMGN: 0.92% (p99 0.92%, success 100.0%, sample 1031880) 4. Photon: 0.97% (p99 0.97%, success 100.0%, sample 23612.2) 5. Terminal: 0.99% (p99 0.99%, success 100.0%, sample 159669) 6. Trojan: 1.03% (p99 1.03%, success 100.0%, sample 48861) 7. Axiom: 1.10% (p99 1.10%, success 100.0%, sample 995179) 8. Maestro: 1.51% (p99 1.51%, success 100.0%, sample 12589.8) **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: pump.fun leads 24h volume at $102.04M (24h) on Solana DEX volume: pump.fun vs Axiom vs GMGN vs Fomo, live 24h. **Rankings (p50, 24h):** 1. pump.fun: $102.04M (p99 $102.04M, success 100.0%, sample n/a) 2. Axiom: $83.29M (p99 $83.29M, success 100.0%, sample n/a) 3. Fomo: $78.04M (p99 $78.04M, success 100.0%, sample n/a) 4. GMGN: $18.61M (p99 $18.61M, success 100.0%, sample n/a) 5. Trojan: $3.39M (p99 $3.39M, success 100.0%, sample n/a) 6. Photon: $1.15M (p99 $1.15M, success 100.0%, sample n/a) 7. BullX: $529.0K (p99 $529.0K, success 100.0%, sample n/a) **Methodology**: - Source: DeFiLlama public chain overview APIs (api.llama.fi/overview/dexs/solana and overview/fees/solana?dataType=dailyRevenue), which report SOLANA-scoped totals per protocol. Multichain platforms such as GMGN therefore show their Solana volume only, keeping every row comparable. No authentication required. - Poll cadence: harness fetches every 30 minutes and updates Prometheus gauges immediately. - Fomo caveat: DeFiLlama attributes Fomo volume from on-chain Solana swaps matched to its fee wallet, while its revenue figure also includes relay fees the Fomo team self-reports. Fomo's displayed revenue-to-volume ratio (~5%) versus its stated 0.5% fee implies substantially higher total activity than the on-chain volume shown here; its Hyperliquid perps flow is tracked separately on the hyperliquid-frontends bench. - Volume: total24h and total7d fields, sum of swap notional values in USD attributed to this platform on Solana. DeFiLlama aggregates in daily buckets with roughly a 10-hour indexing delay, so intraday values are flat by construction and step once per day. - 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 $173.17 (24h) on Average swap size on Solana: pump.fun vs GMGN vs Fomo vs Axiom, live. **Rankings (p50, 24h):** 1. BasedBot: $173.17 (p99 $173.17, success 100.0%, sample 135818) 2. Maestro: $129.78 (p99 $129.78, success 100.0%, sample 17973) 3. GMGN: $128.42 (p99 $128.42, success 100.0%, sample 877238) 4. Photon: $91.57 (p99 $91.57, success 100.0%, sample 26466) 5. Phantom: $87.72 (p99 $87.72, success 100.0%, sample 181342) 6. Bloom: $85.76 (p99 $85.76, success 100.0%, sample 11794) 7. Terminal: $65.58 (p99 $65.58, success 100.0%, sample 246002) 8. Trojan: $60.19 (p99 $60.19, success 100.0%, sample 78683) 9. Axiom: $55.39 (p99 $55.39, success 100.0%, sample 1637370) 10. pump.fun: $51.29 (p99 $51.29, success 100.0%, sample 558170) 11. Fomo: $40.11 (p99 $40.11, success 100.0%, sample 1300070) **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.64M (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.64M (p99 1.64M, success 100.0%, sample 1637370) 2. Fomo: 1.30M (p99 1.30M, success 100.0%, sample 1300070) 3. GMGN: 877.2K (p99 877.2K, success 100.0%, sample 877238) 4. pump.fun: 558.2K (p99 558.2K, success 100.0%, sample 558170) 5. Terminal: 246.0K (p99 246.0K, success 100.0%, sample 246002) 6. BasedBot: 135.8K (p99 135.8K, success 100.0%, sample 135818) 7. Trojan: 78.7K (p99 78.7K, success 100.0%, sample 78683) 8. Photon: 26.5K (p99 26.5K, success 100.0%, sample 26466) 9. Maestro: 9,516 (p99 9,516, success 100.0%, sample 9516) **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: Paradex posts the lowest liquidation rate at 0.00004% (24h avg) on Perp DEX liquidation rate: 24h liquidated notional as % of open interest, live. **Rankings (p50, 24h):** 1. Paradex: 0.00004% (p99 0.00021%, success 100.0%, sample 2880) 2. Lighter: 0.00050% (p99 0.0049%, success 100.0%, sample 2880) 3. dYdX v4: 0.11% (p99 0.14%, success 100.0%, sample 2880) 4. Hyperliquid: 0.50% (p99 0.76%, 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 (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=&end_at= 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 521 ms (p50, 24h) on Fastest free Starknet RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Lava Network: 521 ms (p99 1.25 s, success 23.4%, sample 4317.9) 2. 1RPC: 529 ms (p99 529 ms, success 0.0%, sample 4319.75) 3. OnFinality: 800 ms (p99 2.69 s, success 10.1%, 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":,"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: Ankr posts the lowest rpc latency at 223 ms (p50, 24h) on Fastest free Stellar Soroban RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Ankr: 223 ms (p99 2.12 s, success 99.1%, sample 4317.76) 2. Gateway.fm: 228 ms (p99 273 ms, success 99.4%, sample 4317.76) 3. Lightsail Network: 310 ms (p99 627 ms, success 100.0%, sample 4315.76) 4. SorobanRPC.com: 324 ms (p99 819 ms, success 99.2%, sample 4305.76) 5. OnFinality: 344 ms (p99 909 ms, success 56.5%, sample 4315.76) **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":,"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: BlockVision posts the lowest rpc latency at 45 ms (p50, 24h) on Fastest free Sui RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. BlockVision: 45 ms (p99 1.93 s, success 72.7%, sample 4313.76) 2. PublicNode: 86 ms (p99 219 ms, success 100.0%, sample 4318.76) 3. OnFinality: 101 ms (p99 2.41 s, success 100.0%, sample 4316.76) 4. Suiet: 191 ms (p99 334 ms, success 100.0%, sample 4319.76) **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":,"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 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: 79 ms (p99 306 ms, success 100.0%, sample 4319.76) 2. Aptos Labs (Fullnode): 79 ms (p99 311 ms, success 100.0%, sample 4319.76) **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 /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 797 ms (p50, 24h) on Fastest free XRP Ledger RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Ripple: 797 ms (p99 1.13 s, success 100.0%, sample 4315.76) **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 27 ms (p50, 24h) on Fastest free Algorand RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Tatum: 27 ms (p99 89 ms, success 75.8%, sample 4306.76) 2. AlgoNode: 65 ms (p99 90 ms, success 100.0%, sample 4315.76) 3. Nodely: 68 ms (p99 112 ms, success 100.0%, sample 4306.76) **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 /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 35 ms (p50, 24h) on Fastest free Gram RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Tatum: 35 ms (p99 90 ms, success 75.8%, sample 4303.75) 2. TON Center: 188 ms (p99 575 ms, success 100.0%, sample 4319.76) 3. OnFinality: 211 ms (p99 2.39 s, success 100.0%, sample 4308.76) 4. Uniblock: 455 ms (p99 1.15 s, success 60.5%, sample 4312.76) **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":,"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 28 ms (p50, 24h) on Fastest free NEAR RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. FastNEAR: 28 ms (p99 69 ms, success 100.0%, sample 4315.76) 2. dRPC: 180 ms (p99 507 ms, success 95.9%, sample 4313.76) 3. NEAR Foundation: 3.03 s (p99 3.06 s, success 99.9%, sample 4314.76) **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":,"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 Foundation 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 Foundation: 81 ms (p99 322 ms, success 100.0%, sample 4318.76) 2. Flow Access Node: 82 ms (p99 321 ms, success 100.0%, sample 4306.76) **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 /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 242 ms (p50, 24h) on Fastest free Hedera RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Hashio: 242 ms (p99 710 ms, success 100.0%, sample 4308.76) **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":,"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 56 ms (p50, 24h) on Fastest free Nervos CKB RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. CKBapp: 56 ms (p99 193 ms, success 100.0%, sample 4317.76) 2. Nervos Foundation: 214 ms (p99 660 ms, success 100.0%, sample 4313.76) **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":,"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 173 ms (p50, 24h) on Fastest free MultiversX RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. MultiversX Gateway: 173 ms (p99 296 ms, success 100.0%, sample 4306.76) 2. MultiversX API: 193 ms (p99 867 ms, success 100.0%, sample 4307.76) 3. Elrond API: 215 ms (p99 868 ms, success 99.9%, sample 4305.76) **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 /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 17 ms, success 100.0%, sample 4313.76) 2. NGD: 3 ms (p99 16 ms, success 100.0%, sample 4317.76) 3. NSPCC: 162 ms (p99 1.00 s, success 100.0%, sample 4318.76) **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":,"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 180 ms (p50, 24h) on Fastest free Tezos RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. TezBeta: 180 ms (p99 742 ms, success 98.3%, sample 4317.76) 2. TzKT (Baking Bad): 275 ms (p99 632 ms, success 99.9%, sample 4309.81) 3. SmartPy: 310 ms (p99 600 ms, success 100.0%, sample 4319.76) 4. TCInfra: 523 ms (p99 627 ms, success 100.0%, sample 4318.76) **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 232 ms (p50, 24h) on Fastest free EOS RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. EOS Nation: 232 ms (p99 1.09 s, success 100.0%, sample 4306.76) 2. Greymass: 266 ms (p99 406 ms, success 100.0%, sample 4314.76) 3. Aloha EOS: 929 ms (p99 1.09 s, success 100.0%, sample 4307.76) **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: VeChain Foundation posts the lowest rpc latency at 180 ms (p50, 24h) on Fastest free VeChain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. VeChain Foundation: 180 ms (p99 778 ms, success 100.0%, sample 4316.76) 2. VeThor Node: 180 ms (p99 796 ms, success 99.8%, sample 4314.76) 3. VeChain.energy: 234 ms (p99 931 ms, success 98.2%, sample 4320.77) **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 207 ms (p50, 24h) on Fastest free Waves RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Waves.Exchange: 207 ms (p99 670 ms, success 99.5%, sample 4312.78) 2. Waves Exchange Node: 209 ms (p99 623 ms, success 100.0%, sample 4311.76) 3. Waves Foundation: 382 ms (p99 1.51 s, success 99.4%, sample 4319.78) **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 217 ms (p50, 24h) on Fastest free WAX RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Greymass: 217 ms (p99 290 ms, success 100.0%, sample 4317.76) 2. WAX Sweden: 492 ms (p99 803 ms, success 100.0%, sample 4304.76) 3. EOSUSA: 667 ms (p99 855 ms, success 100.0%, sample 4319.76) **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 247 ms (p50, 24h) on Fastest free Neon EVM RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. P2P Neon Proxy: 247 ms (p99 1.53 s, success 99.9%, sample 4310.76) 2. Everstake: 252 ms (p99 1.64 s, success 99.9%, sample 4314.76) **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":,"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: Merlin Official posts the lowest rpc latency at 16 ms (p50, 24h) on Fastest free Merlin Chain RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Merlin Official: 16 ms (p99 39 ms, success 100.0%, sample 4306.76) 2. dRPC: 363 ms (p99 700 ms, success 94.7%, sample 4315.76) **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":,"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 14 ms (p50, 24h) on Fastest free Viction RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 14 ms (p99 167 ms, success 96.0%, sample 4311.76) 2. Viction Official: 20 ms (p99 314 ms, success 99.6%, sample 4310.76) 3. Viction RPC2: 21 ms (p99 348 ms, success 99.8%, sample 4320.76) **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":,"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: ThunderToken posts the lowest rpc latency at 36 ms (p50, 24h) on Fastest free ThunderCore RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. ThunderToken: 36 ms (p99 36 ms, success 0.0%, sample 4320.75) 2. ThunderCore Official: 37 ms (p99 37 ms, success 0.0%, sample 4320.75) 3. dRPC: 137 ms (p99 137 ms, success 0.0%, sample 4320.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":,"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 52 ms (p50, 24h) on Fastest free OKTC RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. OKX Chain Official: 52 ms (p99 152 ms, success 100.0%, sample 4306.76) 2. dRPC: 392 ms (p99 651 ms, success 95.7%, sample 4303.76) **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":,"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 92.6K (24h) on Daily active wallets per trading platform: GMGN vs Axiom vs Fomo vs pump.fun, live. **Rankings (p50, 24h):** 1. Fomo: 92.6K (p99 92.6K, success 100.0%, sample 92558) 2. Axiom: 55.7K (p99 55.7K, success 100.0%, sample 55737) 3. GMGN: 46.1K (p99 46.1K, success 100.0%, sample 46090) 4. pump.fun: 18.9K (p99 18.9K, success 100.0%, sample 18924) 5. BasedBot: 16.2K (p99 16.2K, success 100.0%, sample 16153) 6. Terminal: 10.6K (p99 10.6K, success 100.0%, sample 10636) 7. Trojan: 5,724 (p99 5,724, success 100.0%, sample 5724) 8. Photon: 1,881 (p99 1,881, success 100.0%, sample 1881) **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. ## 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 $825.99M (24h) on Perp AMM volume share, live 24h notional ranked. **Rankings (p50, 24h):** 1. Pacifica: $825.99M (p99 $838.68M, success 85.7%, sample 2880) 2. GMX V2: $61.51M (p99 $62.63M, success 66.7%, sample 2880) 3. Gains: $43.86M (p99 $43.86M, success 66.6%, sample 2880) 4. Ostium: $1.98M (p99 $2.51M, 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: 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 token P/E ratio 2026: Hyperliquid, GMX, dYdX, GNS live - Category: Trading - Metric: P/E ratio (x) - Page: https://openchainbench.com/benchmarks/perp-pe-ratio - JSON: https://openchainbench.com/api/stat/perp-pe-ratio - Status: live - Headline: GNS posts the lowest p/e ratio at 2.30x (p50, 24h) on Perp DEX token P/E ratio 2026: Hyperliquid, GMX, dYdX, GNS live. **Rankings (p50, 24h):** 1. GNS: 2.30x (p99 2.30x, success 100.0%, sample 2.29604) 2. GMX: 9.00x (p99 9.00x, success 100.0%, sample 9.00383) 3. DYDX: 25.8x (p99 25.8x, success 100.0%, sample 25.75) 4. DRIFT: 27.0x (p99 27.0x, success 100.0%, sample 26.9803) 5. HYPE: 112.5x (p99 112.5x, success 100.0%, sample 112.544) **Methodology**: - Revenue source: DeFiLlama dailyRevenue (protocol revenue accruing to treasury/holders, not total user fees). - 30-day trailing average: last 30 data points from totalDataChart, filtered for non-zero values. - Annual revenue: 30d avg x 365. - FDV source: CoinGecko /coins/markets fully_diluted_valuation (falls back to market_cap if FDV null). - P/E = FDV / annual_revenue. Null if FDV or revenue unavailable. - Poll cadence: harness fetches DeFiLlama + CoinGecko every 60 minutes. Prometheus scrapes :2112/metrics every 60s. ## Fastest free Dogecoin RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/dogecoin-rpc - JSON: https://openchainbench.com/api/stat/dogecoin-rpc - Status: live - Headline: dRPC posts the lowest rpc latency at 237 ms (p50, 24h) on Fastest free Dogecoin RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. dRPC: 237 ms (p99 810 ms, success 96.2%, sample 4300.76) 2. Tatum: 298 ms (p99 1.09 s, success 75.2%, sample 4305.76) **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 (Tatum, dRPC): {"jsonrpc":"2.0","id":,"method":"getblockcount","params":[]}. Plain HTTP POST. The result is a decimal integer (block count = current height + 1). - Payload (BlockCypher): GET https://api.blockcypher.com/v1/doge/main. Returns a JSON object with a `height` field containing the current block height. - 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 (parsable block height returned), 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=dogecoin. Provider coverage at launch: 3 endpoints (Tatum, dRPC, BlockCypher). ## Fastest free Zcash RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/zcash-rpc - JSON: https://openchainbench.com/api/stat/zcash-rpc - Status: live - Headline: Tatum posts the lowest rpc latency at 186 ms (p50, 24h) on Fastest free Zcash RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Tatum: 186 ms (p99 400 ms, success 75.5%, sample 4315.76) 2. Tatum (Zebra): 207 ms (p99 411 ms, success 74.6%, sample 4308.76) 3. Blockchair: 276 ms (p99 1.12 s, success 100.0%, sample 4314.76) **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 (Tatum zcashd, Tatum Zebra): {"jsonrpc":"2.0","id":,"method":"getblockcount","params":[]}. Plain HTTP POST. The result is a decimal integer (block count = current height + 1). - Payload (Blockchair): GET https://api.blockchair.com/zcash/stats. Returns a JSON object with a data.best_block_height field containing the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 4 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=zcash. Provider coverage at launch: 3 endpoints (Tatum zcashd, Tatum Zebra, Blockchair). ## Fastest Robinhood Chain RPC with API key, measured from Singapore: Chainstack vs Alchemy vs QuickNode - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/keyed-rpc-robinhood - JSON: https://openchainbench.com/api/stat/keyed-rpc-robinhood - Status: live - Headline: Chainstack posts the lowest rpc latency at 3 ms (p50, 24h) on Fastest Robinhood Chain RPC with API key, measured from Singapore: Chainstack vs Alchemy vs QuickNode. **Rankings (p50, 24h):** 1. Chainstack: 3 ms (p99 14 ms, success 100.0%, sample n/a) 2. Alchemy: 5 ms (p99 26 ms, success 100.0%, sample n/a) 3. QuickNode: 67 ms (p99 68 ms, success 100.0%, sample n/a) **Methodology**: - Cadence: every 60 seconds per provider from Singapore. Every figure on this page is scoped to that origin; provider ranking is origin-dependent. Robinhood Chain runs on the Arbitrum Orbit stack with ~100ms block times; the 60s probe cadence captures 600 blocks per hour. - Payload: eth_getBlockByNumber('latest', false) with a rotating JSON-RPC id. Non-cacheable by design: the rotating id defeats body-keyed edge caches and forces the provider to serve a real Robinhood Chain tip. - Authentication: Chainstack Global Node key (node-scoped, dedicated to Robinhood Chain; key in Railway env, not in repo). Alchemy uses its standard multi-chain key. QuickNode uses its shared-endpoint key for Robinhood Chain. All keys in Railway env, not in repo. - Call-result classification: ok (HTTP 200 with usable block number), http_err, jsonrpc_err (HTTP 200 with error body), stale (block more than 20 behind the cross-provider tip), timeout. Latency is recorded only for ok responses. - Cohort: Chainstack, Alchemy, and QuickNode. Infura and Ankr do not currently list Robinhood Chain in their supported networks. ## Fastest free Bitcoin Cash RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/bitcoin-cash-rpc - JSON: https://openchainbench.com/api/stat/bitcoin-cash-rpc - Status: live - Headline: Bitcore (Bitpay) posts the lowest rpc latency at 182 ms (p50, 24h) on Fastest free Bitcoin Cash RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Bitcore (Bitpay): 182 ms (p99 392 ms, success 100.0%, sample 4313.76) 2. BiggestFan Node: 219 ms (p99 900 ms, success 99.7%, sample 4314.76) 3. Blockchair: 275 ms (p99 311 ms, success 99.7%, sample 4312.76) **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 (Blockchair): GET https://api.blockchair.com/bitcoin-cash/stats. Returns a JSON object; the current block height is read from data.best_block_height. - Payload (Bitcore): GET https://api.bitcore.io/api/BCH/mainnet/block/tip. Returns a JSON object with a height field containing the current block height. - Payload (BiggestFan): GET https://rest1.biggestfan.net/v2/blockchain/getBlockchainInfo. Returns a Bitcoin-RPC-compatible JSON object; block height is read from the blocks field. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 2 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=bitcoin-cash. Provider coverage at launch: 3 endpoints (Blockchair, Bitcore, BiggestFan). ## Fastest free Litecoin RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/litecoin-rpc - JSON: https://openchainbench.com/api/stat/litecoin-rpc - Status: live - Headline: Tatum posts the lowest rpc latency at 189 ms (p50, 24h) on Fastest free Litecoin RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Tatum: 189 ms (p99 643 ms, success 75.2%, sample 4311.76) 2. LitecoinSpace: 206 ms (p99 717 ms, success 98.6%, sample 4318.76) **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 (Tatum): {"jsonrpc":"2.0","id":,"method":"getblockcount","params":[]}. Plain HTTP POST. The result is a decimal integer. - Payload (BlockCypher): GET https://api.blockcypher.com/v1/ltc/main. Returns a JSON object with a height field containing the current block height. - Payload (LitecoinSpace): GET https://litecoinspace.org/api/blocks/tip/height. Returns the block height as a plain ASCII integer with no JSON wrapping. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 4 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=litecoin. Provider coverage at launch: 3 endpoints (Tatum, BlockCypher, LitecoinSpace). ## Fastest free Babylon RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/babylon-rpc - JSON: https://openchainbench.com/api/stat/babylon-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 151 ms (p50, 24h) on Fastest free Babylon RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 151 ms (p99 814 ms, success 100.0%, sample 4307.76) 2. Polkachu: 189 ms (p99 375 ms, success 100.0%, sample 4310.76) 3. LavenderFive: 238 ms (p99 366 ms, success 99.8%, sample 4313.76) **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: GET /status. Returns a Tendermint status JSON object; block height is read from result.sync_info.latest_block_height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 40 behind the cross-provider tip), timeout. - 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=babylon. Provider coverage at launch: 3 endpoints (PublicNode, Polkachu, LavenderFive). ## Fastest free Acala RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/acala-rpc - JSON: https://openchainbench.com/api/stat/acala-rpc - Status: live - Headline: Acala (RPC-0) posts the lowest rpc latency at 4 ms (p50, 24h) on Fastest free Acala RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Acala (RPC-0): 4 ms (p99 200 ms, success 100.0%, sample 4312.76) 2. Acala (RPC-2): 4 ms (p99 195 ms, success 100.0%, sample 4317.76) 3. Dwellir: 856 ms (p99 905 ms, success 100.0%, sample 4315.76) **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":,"method":"chain_getHeader","params":[]}. The result contains a number field (hex-encoded block 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 40 behind the cross-provider tip), timeout. - 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=acala. Provider coverage at launch: 3 endpoints (Dwellir, Acala RPC-0, Acala RPC-2). ## Fastest free Interlay RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/interlay-rpc - JSON: https://openchainbench.com/api/stat/interlay-rpc - Status: live - Headline: Interlay posts the lowest rpc latency at 242 ms (p50, 24h) on Fastest free Interlay RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Interlay: 242 ms (p99 806 ms, success 100.0%, sample 4319.76) **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":,"method":"chain_getHeader","params":[]}. The result contains a number field (hex-encoded block 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 40 behind the cross-provider tip), timeout. - 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=interlay. Provider coverage at launch: 1 endpoint (Interlay official api.interlay.io/parachain). ## Fastest free Chihuahua RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/chihuahua-rpc - JSON: https://openchainbench.com/api/stat/chihuahua-rpc - Status: live - Headline: Validatus posts the lowest rpc latency at 166 ms (p50, 24h) on Fastest free Chihuahua RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Validatus: 166 ms (p99 178 ms, success 100.0%, sample 4313.76) 2. Chihuahua: 207 ms (p99 407 ms, success 100.0%, sample 4316.76) **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: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. - 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=chihuahua. Provider coverage at launch: 3 endpoints (Chihuahua official, Polkachu, Validatus). ## Fastest free Sentinel DVPN RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/sentinel-rpc - JSON: https://openchainbench.com/api/stat/sentinel-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 121 ms (p50, 24h) on Fastest free Sentinel DVPN RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 121 ms (p99 421 ms, success 100.0%, sample 4312.76) 2. Polkachu: 205 ms (p99 404 ms, success 100.0%, sample 4308.76) 3. Cosmos Directory: 249 ms (p99 580 ms, success 100.0%, sample 4319.76) **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: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. - 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=sentinel. Provider coverage at launch: 3 endpoints (Polkachu, PublicNode, Cosmos Directory). ## Fastest free Fetch.ai RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/fetchhub-rpc - JSON: https://openchainbench.com/api/stat/fetchhub-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 148 ms (p50, 24h) on Fastest free Fetch.ai RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 148 ms (p99 719 ms, success 100.0%, sample 4321.76) 2. Cosmos Directory: 263 ms (p99 608 ms, success 100.0%, sample 4309.76) 3. Fetch.ai: 338 ms (p99 402 ms, success 100.0%, sample 4313.76) **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: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. - 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=fetchhub. Provider coverage at launch: 3 endpoints (Fetch.ai official, PublicNode, Cosmos Directory). ## Fastest free Union RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/union-rpc - JSON: https://openchainbench.com/api/stat/union-rpc - Status: live - Headline: Nodes.Guru posts the lowest rpc latency at 213 ms (p50, 24h) on Fastest free Union RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Nodes.Guru: 213 ms (p99 394 ms, success 100.0%, sample 4311.76) 2. Stake And Relax: 220 ms (p99 696 ms, success 100.0%, sample 4314.76) 3. High Stakes: 306 ms (p99 1.30 s, success 100.0%, sample 4306.76) **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: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. - 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=union. Provider coverage at launch: 3 endpoints (Nodes.Guru, Stake And Relax, High Stakes). ## Fastest free Shentu RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/shentu-rpc - JSON: https://openchainbench.com/api/stat/shentu-rpc - Status: live - Headline: Polkachu posts the lowest rpc latency at 206 ms (p50, 24h) on Fastest free Shentu RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Polkachu: 206 ms (p99 412 ms, success 100.0%, sample 4314.76) 2. High Stakes: 269 ms (p99 1.25 s, success 100.0%, sample 4320.76) 3. Shentu: 787 ms (p99 1.00 s, success 100.0%, sample 4311.76) **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: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. - 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=shentu. Provider coverage at launch: 3 endpoints (Shentu official, Polkachu, High Stakes). ## Fastest free MANTRA RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/mantrachain-rpc - JSON: https://openchainbench.com/api/stat/mantrachain-rpc - Status: live - Headline: MANTRA posts the lowest rpc latency at 64 ms (p50, 24h) on Fastest free MANTRA RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. MANTRA: 64 ms (p99 263 ms, success 100.0%, sample 4315.76) 2. Polkachu: 189 ms (p99 370 ms, success 100.0%, sample 4307.76) **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: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. - 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=mantrachain. Provider coverage at launch: 3 endpoints (MANTRA official, ITRocket, Polkachu). ## Fastest free Band Protocol RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/bandchain-rpc - JSON: https://openchainbench.com/api/stat/bandchain-rpc - Status: live - Headline: Band Protocol posts the lowest rpc latency at 186 ms (p50, 24h) on Fastest free Band Protocol RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. Band Protocol: 186 ms (p99 386 ms, success 100.0%, sample 4317.76) 2. High Stakes: 286 ms (p99 1.29 s, success 100.0%, sample 4314.76) **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: GET /status. The result.sync_info.latest_block_height field is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 40 behind the cross-provider tip), timeout. - 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=bandchain. Provider coverage at launch: 3 endpoints (Band Protocol official, High Stakes, Stakewolle). ## Fastest free cheqd RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/cheqd-rpc - JSON: https://openchainbench.com/api/stat/cheqd-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 149 ms (p50, 24h) on Fastest free cheqd RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 149 ms (p99 747 ms, success 100.0%, sample 4317.76) 2. NodeStake: 161 ms (p99 938 ms, success 98.6%, sample 4301.76) 3. cheqd: 419 ms (p99 605 ms, success 100.0%, sample 4310.76) **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: GET /status. The result.sync_info.latest_block_height field is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 40 behind the cross-provider tip), timeout. - 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=cheqd. Provider coverage at launch: 3 endpoints (cheqd official, PublicNode, NodeStake). ## Fastest free ICON RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/icon-rpc - JSON: https://openchainbench.com/api/stat/icon-rpc - Status: live - Headline: ICON Foundation posts the lowest rpc latency at 14 ms (p50, 24h) on Fastest free ICON RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. ICON Foundation: 14 ms (p99 37 ms, success 100.0%, sample 4317.76) 2. ICON Community: 196 ms (p99 1.10 s, success 100.0%, sample 4315.76) 3. iconblockchain.xyz: 239 ms (p99 1.34 s, success 100.0%, sample 4313.76) **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: POST /api/v3 with method icx_getLastBlock. The result.height field (decimal integer) is extracted as the current block height. - 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 (parsable block height returned), http_err, jsonrpc_err, stale (block more than 150 behind the cross-provider tip, roughly 5 min at ICON's 2 s block time), timeout. - 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=icon. Provider coverage at launch: 3 endpoints (ICON Foundation, ICON Community, iconblockchain.xyz). ## Fastest free Bitcoin RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/bitcoin-rpc - JSON: https://openchainbench.com/api/stat/bitcoin-rpc - Status: live - Headline: PublicNode posts the lowest rpc latency at 80 ms (p50, 24h) on Fastest free Bitcoin RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. PublicNode: 80 ms (p99 163 ms, success 100.0%, sample 1368.83) 2. dRPC: 168 ms (p99 225 ms, success 98.9%, sample 1356.85) 3. NOWNodes: 613 ms (p99 755 ms, success 100.0%, sample 1370.84) **Methodology**: - Probe: a single getblockcount JSON-RPC POST every 60 seconds per provider from us-east, eu-west and Singapore. Latency is the client-side wall-clock round trip. - Classification: ok (HTTP 200 with a usable height), http_err, jsonrpc_err (HTTP 200 with an error body), stale (tip more than 20 blocks behind the cross-provider max), timeout. Only ok responses contribute latency. - Providers: PublicNode (bitcoin-rpc.publicnode.com), dRPC (bitcoin.drpc.org), NOWNodes (public-btc.nownodes.io, no key, 5 RPS). - Aggregation: p50/p90/p99 via Prometheus quantile_over_time over 24h; the headline cites the cross-region figure and the region tabs re-scope it. ## Fastest free LUKSO RPC, live no-key endpoint latency - Category: RPCs - Metric: RPC latency (ms) - Page: https://openchainbench.com/benchmarks/lukso-rpc - JSON: https://openchainbench.com/api/stat/lukso-rpc - Status: live - Headline: LUKSO Foundation posts the lowest rpc latency at 346 ms (p50, 24h) on Fastest free LUKSO RPC, live no-key endpoint latency. **Rankings (p50, 24h):** 1. LUKSO Foundation: 346 ms (p99 1.37 s, success 100.0%, sample 1368.83) 2. NOWNodes: 594 ms (p99 844 ms, success 100.0%, sample 1363.83) **Methodology**: - Probe: a single eth_getBlockByNumber('latest', false) JSON-RPC POST every 60 seconds per provider from us-east, eu-west and Singapore. Latency is the client-side wall-clock round trip. - Classification: ok (HTTP 200 with a usable block number), http_err, jsonrpc_err, stale (block more than 20 behind the cross-provider tip), timeout. Only ok responses contribute latency. - Providers: LUKSO Foundation (rpc.mainnet.lukso.network), NOWNodes (public-lukso.nownodes.io, no key, 5 RPS), thirdweb (42.rpc.thirdweb.com). - Aggregation: p50/p90/p99 via Prometheus quantile_over_time over 24h; the headline cites the cross-region figure and the region tabs re-scope it. --- 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