# OpenChainBench live state

> Auto-refreshed every 60s · last fetch 2026-10-06T03:45:02.237Z · 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 6 data providers

- Category: Aggregators
- Metric: Head lag (s)
- Page: https://openchainbench.com/benchmarks/aggregator-head-lag
- JSON: https://openchainbench.com/api/stat/aggregator-head-lag
- Status: live
- Headline: Mobula and Serialized both post the lowest head lag, tied at 0.3 s (p50, 24h) across 6 ranked providers.

**Rankings (p50, 24h):**
1. Mobula: 0.3 s (p99 1.0 s, success 99.9%, sample 34524)
2. Serialized: 0.3 s (p99 1.3 s, success 99.9%, sample 34512)
3. Codex: 0.7 s (p99 1.2 s, success 99.9%, sample 34524)
4. OKX: 0.9 s (p99 1.8 s, success 99.9%, sample 25893)
5. Birdeye: 2.1 s (p99 4.1 s, success 99.9%, sample 25893)
6. GeckoTerminal: 29 s (p99 1.9 min, success 99.9%, sample 34524)

**Methodology**:
- Aggregators measured: Mobula, Codex, GeckoTerminal and Serialized on all four chains; OKX and Birdeye on Base, BNB and Solana. Neither can scope a subscription to a pool, so both are subscribed per token and matched to the bench pool by transaction hash, their off-pool trades discarded rather than scored. Both send whole-second timestamps, which is why they are measured only on chains whose headline reads a clock we hold rather than the provider's own.
- Robinhood Chain carries four of the six feeds. Neither OKX nor Birdeye indexes it, measured rather than inferred: both accept the subscription and then deliver nothing (0 trades in 40 to 45 s, on the pool and on its non-stable leg) while Base and BNB on the same code delivered hundreds. An accepted subscription is not evidence of coverage on either feed.
- Chains: Base, BNB Chain, Solana, Robinhood Chain.
- Reference on BNB Chain: a node subscription we hold ourselves, every emission matched to it by transaction hash, the ruler Base uses. Until 2026-10-03 the column used each provider's own timestamp, assuming BNB's chain-supplied timestamps sat within roughly 60 ms of a trade becoming observable. Measured, that gap is 569 ms, so the old column tracked block time more than any pipeline: the four feeds sat within 9% of each other, against the common clock they spread over a factor of four.
- Solana (since 2026-09-16): the headline is the lag behind the first feed to report the trade, our own node subscription included in the race. Solana has no on-chain timestamp with sub-second precision, so the timestamps providers send compare conventions: Mobula's `date` (its ingestion time) read as a constant 0.10 s, Serialized's `at` (blockTime, whole seconds) as 0.75 s, while against a common clock the two feeds are 10 to 30 ms apart.
- Solana zero point: no RPC WebSocket we hold, public or keyed (mainnet-beta, Helius, Alchemy), precedes the providers' geyser feeds, so an absolute zero point is not available and the first observation is the ruler. Our node stays in the race: it validates the hash on chain and bounds the field whenever a feed is slower than a plain RPC subscription.
- Race: every feed's arrival for a transaction is compared to the earliest feed's (ties within 5 ms count as first for each feed involved; trades only one feed reported are not scored). Published on every chain as `head_lag_first_share_pct`, the First to report view: the share of the last 24 h of trades a feed reported before every other feed.
- Race eligibility (since 2026-10-04): only trades our own pool subscription saw are raced. OKX and Birdeye are subscribed per token and see every pool on it, so the book had filled with trades from pools this bench does not measure, scored as a race between those two alone. After the filter, Solana discards hundreds of thousands of off-pool races an hour and scores of order 100, its rate before those feeds arrived. Feeds seeing only our pool had been divided by a denominator they could not enter.
- Consequence for the Solana column: `head_lag_seconds` there is the lag behind the first feed in a race, so it moved with the same fix. Figures published before 2026-10-04 for OKX and Birdeye on that column were measured on a wider set of trades than the other four feeds.
- Solana headline: `head_lag_seconds` is the lag behind the first observation of the trade, our node included, floored at 1 ms. GeckoTerminal polls and lands 15 to 100 s later; it is measured against the same first arrival.
- Reading the Solana column: the leading feed's figure is the floor, not a measured latency. Whichever feed wins a race has a lag of zero by definition, published as 1 ms so the row renders, and over a recent 30 minutes the leader sat on that floor for 94% of its samples with p50 and p90 both at 1 ms. So the gap between the leader and the next feed is not a speed ratio; it is how far behind the others arrived. Read the leader through First to report and the others through their own lag.
- 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`, scraped every 30 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 (2,880 expected per provider per day at the 30 s scrape). 100% means the aggregator's feed was reachable for the full window.
- Coverage is not the same as presence. Birdeye's stream carries part of the bench pool's flow rather than all of it: 106 of 442 and 13 of 44 pool swaps over two Base windows, about a quarter. Its percentiles therefore describe the trades it does report, and the presence ratio above measures whether the feed was reachable, not how much of the pool it covered.
- Cardinality: four aggregators on four chains plus two on three (OKX, Birdeye) is 22 aggregator-chain pairs × 3 regions = 66 active series.
- Probe placement: the three probes run in their named regions on Railway (europe-west4, us-east4, asia-southeast1). Until 2026-09-15 all three ran in asia-southeast1 under regional labels; region columns before that date are three Singapore vantage points.

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

- Category: Bridges
- Metric: Quote latency (ms)
- Page: https://openchainbench.com/benchmarks/bridge-quote-latency
- JSON: https://openchainbench.com/api/stat/bridge-quote-latency
- Status: live
- Headline: Mobula posts the lowest quote latency at 62 ms (p50, 24h) across 8 ranked providers.

**Rankings (p50, 24h):**
1. Mobula: 62 ms (p99 908 ms, success 51.8%, sample 2393)
2. deBridge: 98 ms (p99 2.00 s, success 99.9%, sample 4029)
3. Relay: 261 ms (p99 503 ms, success 99.3%, sample 4581)
4. Across: 285 ms (p99 500 ms, success 100.0%, sample 2303)
5. Squid Router: 338 ms (p99 1.76 s, success 99.5%, sample 573)
6. LI.FI: 764 ms (p99 2.36 s, success 69.2%, sample 3185)
7. Socket Protocol: 1.56 s (p99 4.71 s, success 100.0%, sample 576)
8. Near Intents: 3.13 s (p99 4.97 s, success 99.3%, sample 2859)

**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: every figure on this page is pinned to the EU-West (Paris) origin. A us-east probe also runs and its cells stay in Prometheus for the region breakdown, but they are not pooled into the headline; the sgp probe is down. Execution-path quotes ($3 and $30 tickets) and the R4 meme route quoted by the same loop are excluded from every cell.
- 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: Socket Protocol posts the lowest effective fee at 0.013% (24h avg) across 8 ranked providers.

**Rankings (p50, 24h):**
1. Socket Protocol: 0.013% (p99 0.020%, success 100.0%, sample 2880)
2. Squid Router: 0.017% (p99 0.033%, success 99.0%, sample 2880)
3. Near Intents: 0.039% (p99 0.045%, success 99.3%, sample 20154)
4. Across: 0.059% (p99 0.062%, success 85.7%, sample 17274)
5. Relay: 0.099% (p99 0.13%, success 99.6%, sample 34548)
6. Mobula: 0.20% (p99 0.27%, success 52.6%, sample 34548)
7. LI.FI: 0.38% (p99 0.88%, success 79.5%, sample 34548)
8. deBridge: 1.15% (p99 1.21%, success 100.0%, sample 28791)

**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. 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 69.9% (p50, 24h) across 4 ranked providers.

**Rankings (p50, 24h):**
1. Codex: 69.9% (p99 79.0%, success 100.0%, sample 108178)
2. Serialized: 67.4% (p99 70.8%, success 100.0%, sample 108168)
3. Mobula: 46.4% (p99 50.4%, success 100.0%, sample 108178)
4. Jupiter: 21.3% (p99 25.9%, success 100.0%, sample 76197.5)

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

## Crypto data API with most blockchains in asset registry, live coverage ranking

- Category: Aggregators
- Metric: Asset-registry chains (count)
- Page: https://openchainbench.com/benchmarks/asset-registry-coverage
- JSON: https://openchainbench.com/api/stat/asset-registry-coverage
- Status: live
- Headline: CoinGecko leads asset-registry chains at 468 (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. CoinGecko: 468 (p99 468, success 100.0%, sample 468)
2. CoinPaprika: 312 (p99 312, success 100.0%, sample 312)
3. CoinStats: 150 (p99 150, success 100.0%, sample 150)
4. Mobula: 81 (p99 81, success 100.0%, sample 81)
5. Serialized: 19 (p99 19, success 100.0%, sample 19)

**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 wall-clock measurement per chain

- 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) across 10 ranked chains.

**Rankings (p50, 24h):**
1. Gram: 0.4 s (p99 0.8 s, success 99.9%, sample 209173)
2. BNB: 0.6 s (p99 1.0 s, success 99.9%, sample 30344.5)
3. Stellar: 4.0 s (p99 14 s, success 100.0%, sample 14926.2)
4. Avalanche: 6.2 s (p99 8.3 s, success 99.9%, sample 71004.7)
5. Solana: 8.4 s (p99 10 s, success 100.0%, sample 2880)
6. TRON: 57 s (p99 1.0 min, success 100.0%, sample 2880)
7. Ethereum: 15.9 min (p99 19.0 min, success 100.0%, sample 2880)
8. Monero: 19.9 min (p99 36.9 min, success 100.0%, sample 2880)
9. Litecoin: 32.6 min (p99 52.3 min, success 54.7%, sample 2880)
10. Bitcoin: 47.5 min (p99 86.0 min, success 100.0%, sample 173.06)

**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.0024% (24h avg) across 11 ranked venues.

**Rankings (p50, 24h):**
1. Lighter: 0.0024% (p99 0.0079%, success 99.7%, sample 2880)
2. Paradex: 0.026% (p99 0.12%, success 100.0%, sample 2880)
3. Extended: 0.027% (p99 0.034%, success 100.0%, sample 2880)
4. Ondo Perps: 0.036% (p99 0.053%, success 100.0%, sample 2880)
5. Gains: 0.040% (p99 0.040%, success 100.0%, sample 2880)
6. Polymarket: 0.043% (p99 0.088%, success 100.0%, sample 2880)
7. Hyperliquid: 0.047% (p99 0.054%, success 99.0%, sample 2880)
8. edgeX: 0.047% (p99 0.057%, success 100.0%, sample 2880)
9. Aster: 0.051% (p99 0.061%, success 100.0%, sample 2880)
10. GMX v2: 0.060% (p99 0.060%, success 97.4%, sample 2880)
11. dYdX v4: 0.079% (p99 0.18%, success 99.7%, 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 interactive (Retail) taker rate, 0 bps as of 2026-09, + `/orderbook/{market}/interactive?depth=100` walk. Paradex runs two books: the interactive one includes RPI (Retail Price Improvement) maker liquidity and is what UI and interactive-token orders cross; the plain `/orderbook` is the API book, RPI excluded, crossed by Pro (plain API) orders at the 2 bps api-tier fee.
- Paradex, continued: the two books diverge on thin pairs (SOL on 2026-09-22: 0.03 % spread on the interactive book against 1.4 % on the API book), so the bench reads the interactive book as the cost of opening a position; an algorithmic taker should add 2 bps and expect the wider API book. The endpoint caps at 100 levels, so the $1M tier can be skipped when the visible book thins.
- Extended: full public book from `/info/markets/<m>/orderbook` + `/stats` funding (1h native). Its taker fee is not exposed by any public endpoint; the documented base rate of 2.5 bps is used and this is the one venue where the fee is not read live.
- All-in formula: `all_in_bps = taker_fee_bps + spread_bps`. Both components emitted as separate metrics for transparency.
- Notional tiers: the same measurement runs at $1,000, $10,000, $100,000 and $1,000,000 by rewalking the already fetched book, published to `perp_fees_all_in_bps_tier{venue, chain, notional}`. The headline `perp_fees_all_in_bps` stays defined at $1,000. A tier the book cannot fill is skipped and counted in `perp_fees_tier_skipped_total`, never extrapolated. Oracle priced venues (GMX v2, Gains) charge a flat percentage of size, so their figure repeats across tiers.
- Book depth for the $1M tier: Lighter is walked on its top 100 levels, dYdX on the full indexer book, Polymarket on up to 500 levels. Hyperliquid returns its 20 best raw levels; when those cannot absorb the tier the harness refetches with nSigFigs=5, the finest price aggregation the API offers, which extends coverage with negligible price rounding.
- Failures (5xx, timeouts, rate limits) leave the previous gauge in place and increment a per-venue `fetch_errors_total` counter. The page falls back to the last successful sample.

## Best wallet labeling API provider

- Category: Aggregators
- Metric: Coverage rate (pct)
- Page: https://openchainbench.com/benchmarks/wallet-labels-coverage
- JSON: https://openchainbench.com/api/stat/wallet-labels-coverage
- Status: live
- Headline: StellarExpert leads coverage rate at 80.3% (24h avg) across 6 ranked providers, measured on EOA.

**Rankings (p50, 24h):**
1. StellarExpert: 80.3% (p99 80.3%, success 80.3%, sample 483.168)
2. Serialized: 74.0% (p99 74.0%, success 100.0%, sample 4857.69)
3. Blockscout: 58.7% (p99 58.7%, success 95.9%, sample 4030.4)
4. Mobula: 49.8% (p99 49.8%, success 99.8%, sample 8640)
5. OLI: 45.6% (p99 45.6%, success 100.0%, sample 5581.94)
6. TonAPI: 35.8% (p99 35.8%, success 78.6%, sample 679.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 88 ms (p50, 24h) across 10 ranked chains.

**Rankings (p50, 24h):**
1. Robinhood Chain: 88 ms (p99 198 ms, success 100.0%, sample 845805)
2. Arbitrum One: 345 ms (p99 835 ms, success 99.9%, sample 320940)
3. Mantle: 1.86 s (p99 3.00 s, success 99.9%, sample 42935.9)
4. Optimism: 1.92 s (p99 2.99 s, success 99.9%, sample 43053.9)
5. Base: 1.95 s (p99 2.99 s, success 99.9%, sample 43042.9)
6. Blast: 1.97 s (p99 4.67 s, success 99.9%, sample 42641.8)
7. Taiko: 1.98 s (p99 4.24 s, success 100.0%, sample 42971.9)
8. zkSync Era: 3.89 s (p99 54.08 s, success 99.8%, sample 11432)
9. Scroll: 4.52 s (p99 59.08 s, success 99.2%, sample 9178.19)
10. Linea: 5.33 s (p99 54.11 s, success 99.9%, sample 9312.23)

**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 32 ms (p50, 24h) across 12 ranked providers.

**Rankings (p50, 24h):**
1. Binance: 32 ms (p99 159 ms, success 100.0%, sample 4319.87)
2. Avalanche: 81 ms (p99 121 ms, success 100.0%, sample 4318.87)
3. PublicNode: 104 ms (p99 316 ms, success 83.6%, sample 298026)
4. Tenderly: 122 ms (p99 145 ms, success 93.2%, sample 129579)
5. Base: 128 ms (p99 179 ms, success 100.0%, sample 4320.87)
6. Arbitrum: 132 ms (p99 190 ms, success 100.0%, sample 4320.87)
7. Nodies: 138 ms (p99 203 ms, success 66.7%, sample 25918.2)
8. Optimism: 168 ms (p99 231 ms, success 99.9%, sample 4319.87)
9. MeowRPC: 174 ms (p99 364 ms, success 99.9%, sample 8635.73)
10. dRPC: 201 ms (p99 506 ms, success 90.5%, sample 297934)
11. NOWNodes: 206 ms (p99 344 ms, success 78.8%, sample 21593.4)
12. Flashbots: 339 ms (p99 482 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per (provider, chain) pair, from each of 3 Railway replicas (us-east Virginia, eu-west Amsterdam, sgp Singapore). The harness stamps a `region` label on every metric from `$RAILWAY_REPLICA_REGION`. Headline p50/p90/p99 are the mean of per (chain, region) `quantile_over_time` cells: all 3 regions, and on the All chains tab every chain the provider serves. Per-region breakdowns are on the time-series chart.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency: client-side `time.Now()` delta around the round-trip, in milliseconds. Exposed as both a gauge (`rpc_latency_milliseconds`) and a histogram (`rpc_latency_milliseconds_histogram`) with buckets 50 ms → 10 s, so p50/p90/p99 are computed via Prometheus `histogram_quantile` / `quantile_over_time`. Latency is recorded only for calls classified `ok`; failed calls never enter the latency distribution, so every percentile is conditional on success.
- Call-result classification: `ok` (HTTP 200 + non-empty result), `http_err` (status ≠ 200 or transport failure), `jsonrpc_err` (HTTP 200 with an `error` field, the Cloudflare-eth trap), `stale` (returned block more than 20 behind the cross-provider tip for that chain), `timeout`. Counter `rpc_call_total{result}` powers the reliability leaderboard.
- Success gating: because failed probes record no latency, a mostly failing endpoint can post a fast p50 from its rare successes. The ledger pairs every latency figure with a Success column computed as ok calls over total calls in the same 24h window; read rows below 50 percent success as degraded. Providers with under 5 percent success lose their latency series to Prometheus staleness and are pinned below the table as unresponsive instead of being ranked.
- Archive depth: every 5 minutes we issue `eth_getBalance` at (head, depth) for `depth` in {300, 7200, 216_000, 1_296_000, 5_000_000}. Gauge `rpc_archive_depth_supported{depth}` is 1 when the response is non-pruned, 0 otherwise. The 300/7200 thresholds cover Geth's default pruned-cap range; 216k ≈ 1 month; 1.3M ≈ 6 months; 5M ≈ genesis-era full archive.
- Chain coverage: 26 chains (24 EVM plus Solana and Polkadot). EVM majors: Ethereum, Arbitrum, Base, Optimism, Avalanche, BNB, Polygon, Linea, Scroll, Mantle. EVM long-tail: Sonic, Gnosis, Celo, Blast, Taiko, Moonbeam, Berachain, zkSync, Cronos, Fraxtal, Unichain, Soneium, Monad, MegaETH. Non-EVM: Solana (getSlot probe), Polkadot (chain_getHeader probe). Provider matrix per chain is documented in `harnesses/rpc-capabilities/cmd/script/config.go`.
- Excluded: 1RPC (delisted 2026-07-09, under 13% success even at two chains and one probe per minute), Ankr (key-gated), gateway.fm (29 req/IP budget too tight for 15s polling), LlamaRPC + BlockPI + OmniaTech (Cloudflare 521 region-blocked), Alchemy demo (rate-limited dead), NodeReal + GetBlock + Chainstack (key-gated). Blink, formerly Merkle (no public eth_getBlockByNumber) + Lava and MeowRPC outside ETH/Arb excluded. Every (provider, chain) was live-verified no-key before inclusion.

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

- Category: RPCs
- Metric: Gap vs realized (gwei)
- Page: https://openchainbench.com/benchmarks/gas-estimation
- JSON: https://openchainbench.com/api/stat/gas-estimation
- Status: live
- Headline: Owlracle posts the lowest gap vs realized at 0.925 gwei (p50, 24h) across 4 ranked providers.

**Rankings (Gap p99 (24h), 24h):**
1. Owlracle: Gap p99 (24h) 0.925 gwei, Gap p90 0.691 gwei, Gap p50 (typical) 0.162 gwei (success 99.2%, sample 1440.5)
2. PublicNode: Gap p99 (24h) 0.936 gwei, Gap p90 0.413 gwei, Gap p50 (typical) 0.075 gwei (success 100.0%, sample 7199.5)
3. Etherscan: Gap p99 (24h) 1.000 gwei, Gap p90 0.884 gwei, Gap p50 (typical) 0.199 gwei (success 100.0%, sample 5760)
4. MetaMask: Gap p99 (24h) 2 gwei, Gap p90 1.95 gwei, Gap p50 (typical) 1.8 gwei (success 100.0%, sample 7199.5)

**Methodology**:
- Chains: Ethereum (chainid=1), Polygon PoS (chainid=137), Arbitrum One (chainid=42161). Ethereum and Polygon are EIP-1559 with dynamic base fee. Arbitrum is included as an L2 reference where priority fee converges to ~0 (centralised sequencer, no MEV auction); the bench shows this empirically. Actually-meaningful L2 cost is L1 data fee, planned for a separate bench. BNB Chain excluded (not EIP-1559). Avalanche C-Chain also collapses to ~0 priority.
- Oracles per chain. Ethereum + Polygon: PublicNode feeHistory, Owlracle, Etherscan v2 (free tier), MetaMask. Avalanche: same set minus Etherscan (free plan restricted for chainid 43114).
- Per-oracle endpoints. PublicNode `eth_feeHistory` on each chain's RPC; Owlracle `/v4/{eth|poly|avax}/gas` (slug per chain); Etherscan v2 `?chainid=<N>&module=gastracker&action=gasoracle`; MetaMask `gas.api.cx.metamask.io/networks/<N>/suggestedGasFees` (public no-key, EIP-1559 low/medium/high mapped to p25/p50/p90).
- Cadences. PublicNode feeHistory and MetaMask every 12s per chain; Owlracle every 60s per chain (free quota ceiling); Etherscan every 15s per chain with a global rate-gate enforcing ≥6s between any two Etherscan requests across chains (no-key limit is 1 req/5s per IP, shared).
- Tier normalization. Each oracle's named tiers (fast / standard / slow / safe / propose) are mapped onto a unified p25 / p50 / p75 / p90 / p99 scheme. The leaderboard ranks the p50 tier (the standard speed wallets use by default).
- Realized priority fee. For each pending block, the harness pulls the full block via `eth_getBlockByNumber(.., true)` on the chain's primary RPC and computes p25/p50/p75/p90/p99 directly from the actual effective `maxPriorityFeePerGas` values across every included transaction. Every tier is a real percentile of the mined block, none are interpolated. Empty or low-tx blocks (`gas_realized_tx_count` near zero) are surfaced separately because the realized percentile is noisy when tx count is low.
- Realized-side independence check. Each chain configures a second RPC on a different upstream (dRPC / native chain RPC) as `GAS_REALIZED_RPC_VERIFY_<CHAIN>`; on each block the harness cross-checks baseFee and increments `gas_realized_quorum_disagreement_total{chain, kind}` on mismatch. Primary is still trusted; the counter makes visible whether our ground truth is actually independent across upstreams.
- Realized base fee. Recorded for completeness as `gas_realized_base_gwei{chain}` and per-oracle baseFee error as `gas_error_base_gwei{oracle, chain}`. Not the ranking signal since every EIP-1559 oracle inherits this from `eth_feeHistory` and converges.
- Pending buffer. Per (oracle, chain) in-memory map of predictions waiting on a realized block. TTL is ~25 blocks (~5 minutes on Ethereum, ~50 seconds on Polygon due to faster blocks). Beyond that, predictions are dropped as no-longer-informative. Buffer growth surfaces via `gas_pending_buffer_size{oracle, chain}`.
- Polling result classification. `ok`, `http_err`, `parse_err`, `throttled` (HTTP 429 or oracle-specific quota message), `timeout`. Counter `gas_oracle_call_total{oracle, result, chain}` powers the reliability column.
- Ranking metric. The table ranks on the p99 of the absolute gap over 24h, not the p50. At current fee levels the typical-minute gaps are fractions of a micro-gwei apart across oracles (ranking noise); the p99 captures behaviour during the volatile minutes where a wrong prediction either overpays or misses the block. The typical p50 and p90 gaps stay visible as secondary columns.
- Prediction age disclosure. `gas_prediction_age_seconds{oracle, chain}` records the wall-clock time between an oracle's poll returning and the realized block being graded. This surfaces the free-tier cadence asymmetry (Owlracle at 60s vs PublicNode at 12s vs Etherscan at 15s) so readers can see how much of an oracle's error is stale-sample rather than model quality; it is not part of the ranking, only a diagnostic column.
- Over/under split. In parallel with the absolute-error histogram, the harness emits `gas_error_priority_over_gwei_histogram` (predicted > realized, cost = overpay) and `gas_error_priority_under_gwei_histogram` (predicted < realized, cost = transaction stuck). Same buckets. The two branches lets the leaderboard decompose asymmetric behaviour: inclusion-confidence oracles skew fat on the over side by design, percentile trackers skew fat on the under side during spikes.
- Lag=2 secondary grade. `gas_error_priority_lag2_gwei_histogram` grades each prediction against the block 2 slots after its target, not the very-next block. Removes the latency-race bias where whoever scraped the mempool 100ms before us wins by construction; closer to the wallet UX (sign, broadcast, propagate) than block+1. Same buckets as the primary histogram so a leaderboard column can plot the two side by side.
- Asymmetric Pinball Loss (APL). `gas_error_priority_apl_gwei_histogram` emits a proper scoring rule (Koenker & Bassett 1978): per sample `(1-τ)·over_gap` if the oracle over-predicted, else `τ·under_gap`, with τ=0.9. Encodes wallet UX asymmetry: under-prediction (tx stuck) is 9× more costly than over-prediction (small overpay). Same buckets as the abs error histogram. Rank-stable at n=few-hundred samples where p99 of abs error is still dominated by 2-3 tail blocks.
- Covered rate. Share of time (24h) each oracle's posted p50-tier prediction was at or above the realized p50 priority fee, recorded as `ocb:gas_p50_covered:pct_24h` via a recording rule. Same-instant gauge comparison (current prediction vs latest realized block), a proxy pending a harness-side matched counter. High = errs on the side of inclusion; low = under-bids vs the block's realized median.
- Excluded by design. (a) BNB Chain (not EIP-1559). (b) L2 OP Stack chains (Optimism, Base, Arbitrum), priority fee ≈ 0 there because sequencer is centralised, the relevant cost is L1 data fee which is a different metric and belongs in a separate bench. (c) Rough median oracles that publish only a single number (no tier breakdown). (d) Solana, different fee model entirely (lamports per CU, MEV via Jito), separate bench needed.

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

- Category: Trading
- Metric: Peg deviation (bps)
- Page: https://openchainbench.com/benchmarks/stablecoin-peg
- JSON: https://openchainbench.com/api/stat/stablecoin-peg
- Status: live
- Headline: DAI posts the lowest peg deviation at 0.00062% (p50, 24h) across 3 ranked providers.

**Rankings (p50, 24h):**
1. DAI: 0.00062% (p99 0.0025%, success 100.0%, sample 7200.5)
2. USDC: 0.015% (p99 0.017%, 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% (p50, 24h) across 3 ranked stablecoins.

**Rankings (p50, 24h):**
1. USDe: 0.0050% (p99 0.015%, success 100.0%, sample 17280)
2. USDC: 0.014% (p99 0.033%, success 100.0%, sample 17280)
3. FDUSD: 0.095% (p99 0.12%, success 100.0%, sample 17280)

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

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

- Category: Trading
- Metric: Execution ratio (pct)
- Page: https://openchainbench.com/benchmarks/buyback-audit
- JSON: https://openchainbench.com/api/stat/buyback-audit
- Status: live
- Headline: Hyperliquid leads execution ratio at 185.9% (7d avg) across 2 ranked protocols.

**Rankings (p50, 7d):**
1. Hyperliquid: 185.9% (p99 185.9%, success 100.0%, sample 26403600)
2. Sky (Maker): 0% (p99 0%, success 100.0%, sample 0)

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

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

- Category: Trading
- Metric: Max cross-oracle deviation (bps)
- Page: https://openchainbench.com/benchmarks/oracle-deviation
- JSON: https://openchainbench.com/api/stat/oracle-deviation
- Status: live
- Headline: XRP/USD posts the lowest max cross-oracle deviation at 0.013% (p50, 24h) across 10 ranked providers.

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

## Highest staking yield, live validator net APR across 7 PoS chains

- Category: Blockchains
- Metric: Net yield (bps)
- Page: https://openchainbench.com/benchmarks/validator-yield
- JSON: https://openchainbench.com/api/stat/validator-yield
- Status: live
- Headline: Cosmos Hub leads net yield at 9.69% (24h avg) across 6 ranked chains.

**Rankings (p50, 24h):**
1. Cosmos Hub: 9.69% (p99 9.89%, success 100.0%, sample 180)
2. Avalanche: 6.80% (p99 8.33%, success 98.2%, sample 100)
3. Cardano: 4.95% (p99 5.00%, success 100.0%, sample 50)
4. Solana: 4.88% (p99 5.41%, success 99.9%, sample 200)
5. Ethereum: 2.51% (p99 2.51%, success 100.0%, sample 1)
6. Hyperliquid: 2.18% (p99 2.24%, success 78.4%, 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: Trust Wallet leads builder fees collected at $20.9K (24h) across 104 ranked providers.

**Rankings (Revenue, 24h):**
1. Trust Wallet: Revenue $20.9K, Volume $22.08M, $ / user $19.52 (success 100.0%, sample 9161)
2. Phantom: Revenue $15.4K, Volume $28.54M, $ / user $5.29 (success 100.0%, sample 23900)
3. FOMO: Revenue $13.3K, Volume $26.99M, $ / user $8.98 (success 100.0%, sample 17350)
4. MetaMask: Revenue $12.3K, Volume $12.28M, $ / user $14.94 (success 100.0%, sample 8600)
5. Liquid Perps: Revenue $5,646.76, Volume $15.28M, $ / user $10.67 (success 100.0%, sample 8195)
6. Rabby: Revenue $4,788.89, Volume $23.94M, $ / user $7.81 (success 100.0%, sample 9847)
7. 0x7cc0…e781: Revenue $4,269.93, Volume $14.51M, $ / user $2.66 (success 100.0%, sample 8712)
8. Invo: Revenue $4,073.29, Volume $11.64M, $ / user $0.9731 (success 100.0%, sample 31864)
9. OneKey: Revenue $3,674.7, Volume $7.36M, $ / user $43.23 (success 100.0%, sample 1285)
10. Legend Trade: Revenue $2,525.31, Volume $4.90M, $ / user $2.84 (success 100.0%, sample 6352)
11. tuleep.trade: Revenue $2,254.66, Volume $11.27M, $ / user $322.09 (success 100.0%, sample 4502)
12. Bitget Wallet: Revenue $2,048.64, Volume $4.21M, $ / user $11.71 (success 100.0%, sample 1377)
13. Insilico: Revenue $1,783.88, Volume $17.85M, $ / user $13.83 (success 100.0%, sample 10244)
14. 0xf85a…5688: Revenue $1,324.38, Volume $1.89M, $ / user $16.76 (success 100.0%, sample 1462)
15. Hyperdash: Revenue $1,115.28, Volume $6.67M, $ / user $7.64 (success 100.0%, sample 6964)
16. Tread.fi: Revenue $998.05, Volume $9.42M, $ / user $10.29 (success 100.0%, sample 62630)
17. Mass.money: Revenue $856.32, Volume $1.55M, $ / user $16.47 (success 100.0%, sample 1103)
18. Metascalp: Revenue $802.22, Volume $4.18M, $ / user $5.81 (success 100.0%, sample 8542)
19. Dextrabot: Revenue $647.17, Volume $1.18M, $ / user $35.95 (success 100.0%, sample 465)
20. 0xdbc2…97a6: Revenue $627.29, Volume $628.6K, $ / user $10.28 (success 100.0%, sample 317)
21. VergeX: Revenue $598.76, Volume $1.50M, $ / user $3.61 (success 100.0%, sample 3082)
22. based.app: Revenue $496.2, Volume $2.55M, $ / user $3.04 (success 100.0%, sample 2743)
23. Moonbot: Revenue $443.11, Volume $2.95M, $ / user $6.92 (success 100.0%, sample 1976)
24. Infinex: Revenue $406.39, Volume $812.8K, $ / user $18.47 (success 100.0%, sample 410)
25. Wallet V: Revenue $352.51, Volume $1.76M, $ / user $3.42 (success 100.0%, sample 1439)
26. 0x9f83…31d9: Revenue $340.57, Volume $894.0K, $ / user $7.92 (success 100.0%, sample 686)
27. Dreamcash: Revenue $334.78, Volume $755.0K, $ / user $3.25 (success 100.0%, sample 847)
28. Pear: Revenue $287.31, Volume $628.7K, $ / user $10.26 (success 100.0%, sample 1246)
29. Dexly Trade: Revenue $283.46, Volume $566.9K, $ / user $7.66 (success 100.0%, sample 448)
30. Onchain.cc: Revenue $270.82, Volume $534.0K, $ / user $0.6822 (success 100.0%, sample 1646)
31. MetaMask (alt): Revenue $269.99, Volume $270.0K, $ / user $4.65 (success 100.0%, sample 280)
32. ApexLiquid: Revenue $244.67, Volume $491.2K, $ / user $3.95 (success 100.0%, sample 989)
33. Axiom: Revenue $171.04, Volume $1.71M, $ / user $1.24 (success 100.0%, sample 1386)
34. Markets Mobile: Revenue $147.64, Volume $221.2K, $ / user $3.43 (success 100.0%, sample 378)
35. BullpenFi: Revenue $146.02, Volume $467.6K, $ / user $4.87 (success 100.0%, sample 504)
36. Wunder: Revenue $145.79, Volume $420.9K, $ / user $0.9851 (success 100.0%, sample 1569)
37. Rainbow: Revenue $136.61, Volume $273.2K, $ / user $3.33 (success 100.0%, sample 368)
38. Senpi: Revenue $134.44, Volume $291.3K, $ / user $1.08 (success 100.0%, sample 959)
39. STRYX: Revenue $86.7, Volume $315.9K, $ / user $28.9 (success 100.0%, sample 79)
40. Splash: Revenue $75.89, Volume $549.6K, $ / user $25.3 (success 100.0%, sample 217)
41. VOOI: Revenue $57.25, Volume $311.7K, $ / user $2.86 (success 100.0%, sample 886)
42. Gem Wallet: Revenue $53.29, Volume $118.4K, $ / user $8.88 (success 100.0%, sample 260)
43. Dexari: Revenue $43.8, Volume $48.9K, $ / user $4.38 (success 100.0%, sample 59)
44. 0x42f3…f992: Revenue $35.43, Volume $134.6K, $ / user $1.86 (success 100.0%, sample 168)
45. defi.app: Revenue $29.36, Volume $58.7K, $ / user $2.45 (success 100.0%, sample 106)
46. HyperX: Revenue $24.19, Volume $60.1K, $ / user $0.8341 (success 100.0%, sample 643)
47. 0x446f…d6c6: Revenue $23.8, Volume $79.3K, $ / user $11.9 (success 100.0%, sample 28)
48. Nansen: Revenue $23.32, Volume $58.7K, $ / user $1.17 (success 100.0%, sample 97)
49. Origami Tech: Revenue $21.75, Volume $217.6K, $ / user $1.98 (success 100.0%, sample 1032)
50. Cwallet: Revenue $18.75, Volume $116.4K, $ / user $1.17 (success 100.0%, sample 183)
51. pvp.trade: Revenue $17.11, Volume $45.5K, $ / user $1.01 (success 100.0%, sample 55)
52. cro.trade: Revenue $14.24, Volume $23.7K, $ / user $2.37 (success 100.0%, sample 23)
53. CCXT: Revenue $12.3, Volume $129.6K, $ / user $0.2796 (success 100.0%, sample 491)
54. CoinPilot: Revenue $12.29, Volume $24.6K, $ / user $0.3724 (success 100.0%, sample 435)
55. SuperCEXy: Revenue $9.12, Volume $65.4K, $ / user $3.04 (success 100.0%, sample 114)
56. PerpsWLD: Revenue $8.96, Volume $8,956.42, $ / user $2.24 (success 100.0%, sample 25)
57. DeFi Saver: Revenue $7.88, Volume $30.0K, $ / user $2.63 (success 100.0%, sample 22)
58. KuCoin Web3: Revenue $7.72, Volume $15.4K, $ / user $1.29 (success 100.0%, sample 13)
59. Owly.fi: Revenue $6.76, Volume $12.4K, $ / user $1.69 (success 100.0%, sample 18)
60. Arena: Revenue $6.32, Volume $6,757.52, $ / user $1.26 (success 100.0%, sample 18)
61. Katoshi: Revenue $6.26, Volume $20.9K, $ / user $6.26 (success 100.0%, sample 49)
62. Hyprearn: Revenue $4.97, Volume $26.5K, $ / user $0.5517 (success 100.0%, sample 79)
63. 0xc95d…1aca: Revenue $2.48, Volume $199.5K, $ / user $0.6207 (success 100.0%, sample 897)
64. Miracle: Revenue $2.42, Volume $20.9K, $ / user $0.8072 (success 100.0%, sample 152)
65. Okto: Revenue $1.25, Volume $6,949.01, $ / user $0.0893 (success 100.0%, sample 45)
66. Cipher: Revenue $1.1, Volume $3,660.61, $ / user $1.1 (success 100.0%, sample 9)
67. goodcryptoX: Revenue $1.07, Volume $3,327.9, $ / user $0.0821 (success 100.0%, sample 84)
68. Tradoor: Revenue $0.9635, Volume $602.21, $ / user $0.9635 (success 100.0%, sample 46)
69. MarsGO: Revenue $0.3788, Volume $637.2, $ / user $0.1894 (success 100.0%, sample 8)
70. Lit Trade: Revenue $0.2004, Volume $442.79, $ / user $0.1002 (success 100.0%, sample 3)
71. Liminal: Revenue $0.1384, Volume $325.46, $ / user $0.1384 (success 100.0%, sample 21)
72. XBIT: Revenue $0.1040, Volume $519.99, $ / user $0.1040 (success 100.0%, sample 2)
73. 0x53a1…fcd1: Revenue $0.0397, Volume $39.75, $ / user $0.0397 (success 100.0%, sample 1)
74. GTR Trade: Revenue $0.0372, Volume $74.41, $ / user $0.0372 (success 100.0%, sample 7)
75. Sushi: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
76. Blink: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
77. Perpmate: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
78. MinaraAI: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
79. Coin98: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
80. Echosync: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
81. Moontrader: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
82. Ranger Finance: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
83. SuperX: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
84. Supurr: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
85. Unigox: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
86. UXUY: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
87. Grider: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
88. Lootbase: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
89. Superstack: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
90. xTrade Protocol: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
91. Taco Trade: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
92. Silhouette: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
93. FlowBot: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
94. Nautilus Trader: Revenue $0, Volume $86.4K, $ / user $0 (success 100.0%, sample 555)
95. 0xb290…c34a: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
96. Kinto: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
97. HyperSignals: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
98. VibeLiquid: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
99. Slash: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
100. SHAX: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
101. Aura: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
102. TopDog: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
103. Pocket Protector: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
104. UnityWallet: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)

**Methodology**:
- Data source. Hyperliquid publishes one CSV per builder address and UTC day at stats-data.hyperliquid.xyz/Mainnet/builder_fills/<address>/<YYYYMMDD>.csv.lz4, listing every fill that carried that builder code with time, wallet, coin, price, size, taker flag, closed PnL and builder fee in USDC. The feed is public and keyless; a missing file answers 403.
- Cadence. Day D is published early on D+1 (observed 02:45 to 03:30 UTC). The harness re-checks the feed every 30 minutes, downloads new files into a local mirror, and switches the whole cohort to day D once at least five builders have a file and the batch has settled for 45 minutes. Prometheus scrapes the gauges every 30 seconds. End-to-end lag from a fill to this page is 3 to 27 hours.
- Headline calculation. For each builder, the sum of builder_fee over every fill in the day-D file. The 7 day and 30 day figures sum the same field over the files of the 7 and 30 UTC days ending on D, so the three ranges are consistent and every builder is compared on the same days.
- Volume companion. Notional is px times sz per fill, summed the same way for the day, 7 day and 30 day windows.
- Users. Distinct wallets in the day-D file. The 7 day and 30 day counts are unions of the daily wallet sets, never sums, so a wallet active every day counts once.
- Effective fee bps. Builder fees divided by notional, times ten thousand, on day D. The trader perspective on what a representative dollar of flow paid the frontend.
- Builder registry. builders.json in the harness tree is a hand-curated array of slug, name and address for every tracked frontend. A frontend routing through several builder addresses can list them all under one entry and they are merged into one row; MetaMask's documented secondary address stays its own row (MetaMask alt) for continuity with the recorded history. New addresses ship via public PR. Addresses outside the registry are not fetched.
- Exclusions. Native Hyperliquid UI orders carry no builder code and are not attributable; roughly 95 percent of Hyperliquid fills land without one. HIP-3 market fills routed through a frontend count toward that frontend; deployer fees are not part of this feed.
- Reproducibility. Harness source is open in the OCB harness tree. Anyone can run it against the same public feed with the same registry and reproduce every number, no node required.
- Failures. A transport error leaves the previous file and gauge values in place and is retried on the next pass. The cohort never switches to a day before its batch has settled, and the choice of day only moves forward. Restarts re-read the local mirror before touching the feed.

## Cheapest blockchain transaction fee, live across 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: Blast posts the lowest native transfer fee USD at $0.0000021 (p50, 24h) across 21 ranked chains.

**Rankings (p50, 24h):**
1. Blast: $0.0000021 (p99 $0.000183, success 100.0%, sample 20160)
2. Stellar: $0.0000023 (p99 $0.0000023, success 100.0%, sample 20160)
3. Optimism: $0.0000087 (p99 $0.000360, success 100.0%, sample 20160)
4. Litecoin: $0.000158 (p99 $0.000161, success 82.3%, sample 20160)
5. Base: $0.000361 (p99 $0.00211, success 100.0%, sample 20160)
6. Taiko: $0.000500 (p99 $0.00122, success 100.0%, sample 20160)
7. Solana: $0.000603 (p99 $0.000715, success 99.8%, sample 20160)
8. Mantle: $0.000688 (p99 $0.00267, success 100.0%, sample 20160)
9. BNB Chain: $0.000968 (p99 $0.0396, success 100.0%, sample 20160)
10. Robinhood Chain: $0.00115 (p99 $0.00119, success 100.0%, sample 20160)
11. Arbitrum One: $0.00119 (p99 $0.00152, success 100.0%, sample 20160)
12. Avalanche: $0.00156 (p99 $0.0427, success 100.0%, sample 20160)
13. zkSync Era: $0.00258 (p99 $0.00259, success 100.0%, sample 20160)
14. Scroll: $0.00267 (p99 $0.0289, success 100.0%, sample 20160)
15. Gram: $0.00718 (p99 $0.00718, success 100.0%, sample 20160)
16. Sui: $0.00857 (p99 $0.00857, success 100.0%, sample 20160)
17. Linea: $0.0164 (p99 $0.1323, success 100.0%, sample 20160)
18. Ethereum: $0.0211 (p99 $0.7706, success 100.0%, sample 20160)
19. Cardano: $0.0449 (p99 $0.0457, success 100.0%, sample 20160)
20. Monero: $0.0660 (p99 $0.2703, success 100.0%, sample 20160)
21. TRON: $0.0937 (p99 $0.0937, success 100.0%, sample 20160)

**Methodology**:
- Refresh cadence. 30 seconds. One process samples every chain in the table in parallel goroutines.
- Ethereum, BNB Chain and Avalanche 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, Optimism, Base, Blast, Scroll, zkSync Era, Linea, Mantle, Taiko and Robinhood Chain 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 data fee. OP Stack rollups (Optimism, Base, Blast, Mantle): eth_call GasPriceOracle.getL1Fee(bytes) at 0x42..0F on a serialized 113 byte EIP 1559 transfer, added to every tier. Scroll: the same call on L1GasPriceOracle at 0x53..02. Arbitrum: eth_estimateGas on a native transfer returns 21000 plus the L1 calldata component; every tier is scaled by estimated / 21000. zkSync Era, Linea, Taiko and Robinhood Chain: none added, the sequencer gas price already includes data posting.
- Stellar. horizon fee_stats.last_ledger_base_fee (100 stroops outside surge) times one operation. Single tier.
- Gram. 0.005 GRAM, the conservative observed cost of a Wallet v4 transfer; the chain exposes no fee estimate RPC. Single tier.
- 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. GraphQL epoch.referenceGasPrice (the JSON RPC method was retired on public fullnodes in 2026) 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 every native token 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 233 ms (p50, 24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. KyberSwap: 233 ms (p99 1.93 s, success 99.9%, sample 4313.9)
2. Mobula: 473 ms (p99 2.76 s, success 100.0%, sample 4318.9)
3. Bebop: 546 ms (p99 1.37 s, success 100.0%, sample 4319.9)
4. LI.FI: 718 ms (p99 1.69 s, success 61.9%, sample 2639.55)
5. CoW Protocol: 1.91 s (p99 4.78 s, success 100.0%, sample 3456.72)

**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.00116 (p50, 24h) across 7 ranked chains.

**Rankings (p50, 24h):**
1. Osmosis: $0.00116 (p99 $0.00116, success 100.0%, sample 20160)
2. Aptos: $0.1236 (p99 $0.1236, success 100.0%, sample 20160)
3. Cardano: $0.3161 (p99 $0.3218, success 100.0%, sample 20160)
4. Stellar: $0.5643 (p99 $0.5643, success 100.0%, sample 20160)
5. Injective: $0.7548 (p99 $0.7548, success 100.0%, sample 20160)
6. Solana: $0.8030 (p99 $0.8110, success 100.0%, sample 20160)
7. Sui: $55.38 (p99 $55.38, 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 /<chain>/tokenfactory/v1beta1/params.denom_creation_fee. Empty array (Osmosis) means gas only, rendered as less than 0.001 dollar. Injective charges a flat 0.1 INJ.
- Cardano. Koios /epoch_params.coins_per_utxo_size. Apply Conway minUTxO formula = (160 byte overhead + 70 byte single asset bundle) × coins_per_utxo_size + 180000 lovelace mint tx fee. Converted to USD via ADA price.
- Stellar. Horizon /ledgers.base_reserve_in_stroops and base_fee_in_stroops on the latest ledger. Total cost = 5 base reserves (the protocol minimum of 2 per new account for issuer and distribution, plus 1 for the trustline) + 2 base fees (create_account + change_trust). Reserves are locked capital, refundable on account closure, counted here because bringing the asset into existence requires them upfront. Converted to USD via XLM price.
- USD prices. api.mobula.io/api/1/market/multi-data?symbols=SOL,SUI,APT,OSMO,INJ,ADA,XLM polled every 5 minutes.
- Failures. Any upstream error increments token_deployment_samples_total{chain,status=error} and leaves the previous gauge value in place.
- EVM chains excluded. Ethereum, BNB Chain, Avalanche, Polygon, Arbitrum, Optimism, Base, Blast, Mantle, opBNB, Celo, Scroll and Linea were previously exposed but relied on a placeholder init bytecode that undercounted real ERC20 deploy cost by 30 to 500x. Removed until the canonical OZ v5 artifact is finalised.

## Hyperliquid HIP-3 dex volume leaderboard

- Category: Trading
- Metric: Volume 24h (usd)
- Page: https://openchainbench.com/benchmarks/hyperliquid-hip3-deployers
- JSON: https://openchainbench.com/api/stat/hyperliquid-hip3-deployers
- Status: live
- Headline: trade.xyz leads volume 24h at $1.99B (24h) across 4 ranked providers.

**Rankings (Volume, 24h):**
1. trade.xyz: Volume $1.99B, Open interest $3.85B, Markets traded 110 (success 100.0%, sample 110)
2. EntropyIO: Volume $36.19M, Open interest $59.56M, Markets traded 9 (success 100.0%, sample 9)
3. Paragon: Volume $4.85M, Open interest $22.50M, Markets traded 29 (success 100.0%, sample 29)
4. Markets by Kinetiq (mkts): Volume $4.06M, Open interest $8.93M, Markets traded 5 (success 100.0%, sample 5)

**Methodology**:
- Data source. The public Hyperliquid info API at api.hyperliquid.xyz/info. perpDexs returns every HIP-3 dex with its namespace, full name and deployer address; metaAndAssetCtxs with the dex parameter returns, per market, the rolling 24h notional volume (dayNtlVlm), open interest in base units and the mark price. No key, no node.
- Attribution. A market belongs to the dex whose namespace prefixes its coin (xyz:AAPL belongs to xyz). Namespaces are unique on chain by construction, so the on-chain registry is the provider list; a newly deployed dex starts being metered on the next poll and joins this page after a short spec review. Core Hyperliquid markets carry no namespace and are excluded, and a dex whose markets are all delisted (flx, vntl, hyna, km, cash on 2026-09-24) is metered but not listed.
- Cadence. The Go harness polls perpDexs and one metaAndAssetCtxs call per dex every 10 minutes. Prometheus scrapes the gauges every 30 seconds. The 24h figure is the chain's own rolling window, so the page is at most about 10 minutes behind the API.
- Headline calculation. For each dex, the sum of dayNtlVlm across its listed markets: the notional traded over the trailing 24 hours as computed by the chain.
- Markets. Two counts per dex: markets currently listed (delisted excluded) and markets with non-zero notional over the trailing 24 hours. A dex with 100 active equity markets and a dex with one commodity market are different products; the columns make that visible next to the volume.
- Open interest. Per market, open interest in base units times the mark price, summed per dex, in USD. A snapshot at poll time, not a window.
- 7 day and 30 day volume. Once a day, on the first poll after 00:00 UTC, the harness stores each dex's 24h notional as the sample for the day that just closed. The 7 day and 30 day figures sum the last 7 and 30 samples. Samples accumulate from the day the feed edition went live, so those figures grow toward the full window and the days-sampled gauge says how many are behind them.
- Deployer fees. HIP-3 deployers configure a fee share and receive a cut of every fill, but the chain's public endpoints do not expose that revenue per fill or per dex. The earlier version of this bench read the deployerFee field from a self-hosted node's fill stream; that node is retired and the column is gone rather than estimated.
- Naming. Every namespace is resolved against the on-chain perpDexs registry: xyz is trade.xyz, mkts (and the retired km) is Markets by Kinetiq, para is Paragon, io is EntropyIO; vntl (Ventuals), cash (Dreamcash), hyna (HyENA) and flx (Felix Exchange) have delisted every market. Attribution is by namespace either way, so the numbers do not depend on naming.
- Reproducibility. Harness source is open in the OCB harness tree (harnesses/hyperliquid-frontends). Anyone can call the same two info endpoints and reproduce every number on this page.
- Failures. A failed poll for one dex leaves its previous gauge values in place; the harness liveness gauge drives the availability column. Daily samples are written once and never overwritten.

## 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: Kalshi posts the lowest funding cost to hold a long 24h at 0 bps (24h avg) across 18 ranked venues.

**Rankings (ETH hold 24h, 24h):**
1. Kalshi: ETH hold 24h 0 bps, BTC 4.91 bps, SOL 0 bps, Annualized 0% (success 100.0%, sample 2880)
2. dYdX v4: ETH hold 24h 0.47 bps, BTC -0.57 bps, SOL -0.04 bps, Annualized 1.71% (success 100.0%, sample 2880)
3. edgeX: ETH hold 24h 1.06 bps, BTC 3.00 bps, SOL 3.00 bps, Annualized 3.86% (success 100.0%, sample 2868)
4. Bybit: ETH hold 24h 1.08 bps, BTC 1.38 bps, SOL -0.65 bps, Annualized 3.94% (success 100.0%, sample 2880)
5. Binance: ETH hold 24h 1.12 bps, BTC 0.53 bps, SOL -0.02 bps, Annualized 4.09% (success 100.0%, sample 2880)
6. Lighter: ETH hold 24h 1.28 bps, BTC 1.84 bps, SOL 2.40 bps, Annualized 4.66% (success 100.0%, sample 2880)
7. OKX: ETH hold 24h 1.61 bps, BTC 1.12 bps, SOL 0.86 bps, Annualized 5.87% (success 100.0%, sample 2880)
8. Aster: ETH hold 24h 1.85 bps, BTC 1.31 bps, SOL 0.26 bps, Annualized 6.76% (success 100.0%, sample 2880)
9. Extended: ETH hold 24h 1.98 bps, BTC 0.41 bps, SOL 0.56 bps, Annualized 7.24% (success 100.0%, sample 2854)
10. ApeX Omni: ETH hold 24h 2.17 bps, BTC 0.31 bps, SOL -3.04 bps, Annualized 7.94% (success 100.0%, sample 2880)
11. Paradex: ETH hold 24h 2.34 bps, BTC 2.49 bps, SOL 1.65 bps, Annualized 8.55% (success 100.0%, sample 2880)
12. Lighter RH: ETH hold 24h 2.39 bps, BTC 2.12 bps, SOL -3.36 bps, Annualized 8.72% (success 100.0%, sample 2880)
13. Vest: ETH hold 24h 2.95 bps, BTC 2.92 bps, SOL -5.19 bps, Annualized 10.8% (success 100.0%, sample 2880)
14. Hyperliquid: ETH hold 24h 3.00 bps, BTC 3.00 bps, SOL 1.83 bps, Annualized 10.9% (success 100.0%, sample 2880)
15. Polymarket: ETH hold 24h 3.00 bps, BTC 1.97 bps, SOL 2.69 bps, Annualized 10.9% (success 100.0%, sample 2880)
16. Ondo Perps: ETH hold 24h 3.00 bps, BTC 3.00 bps, SOL 2.75 bps, Annualized 10.9% (success 100.0%, sample 2880)
17. StandX: ETH hold 24h 3.00 bps, BTC 2.99 bps, SOL 3.00 bps, Annualized 10.9% (success 100.0%, sample 2880)
18. Pacifica: ETH hold 24h 3.38 bps, BTC 2.76 bps, SOL 2.98 bps, Annualized 12.3% (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).
- Native cohort feeds since 2026-09-23 (perp-cohort-stats harness): Lighter and Lighter RH from /funding-rates (8h-normalised feed, rate x 3), Extended from /info/markets (hourly), edgeX from getTicker (4h, interval from fundingTime to nextFundingTime), Pacifica from /info/prices (hourly); Aster reads premiumIndex plus fundingInfo there too.
- 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. Cohort-harness rows (every venue except dYdX and Paradex) lose their gauge five minutes after the last refresh (ten for edgeX and ApeX, read through a ticker cache) and turn red at 15 minutes: a gap in the 24h average is a gap, never the last value repeated. The perp-funding-harness rows (dYdX, Paradex) keep their last value and turn red after 5 minutes of silence. Nothing is 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 joined on 2026-09-23 from its /funding-rates endpoint: the feed is normalised to 8 hours (its Hyperliquid entry is exactly eight times HL's hourly rate, and the native value matched the Mobula-sourced one to the second decimal at the switch), so the 24h figure is the rate times three.
- 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. Both harnesses are open in the OCB harness tree: perp-cohort-stats (the native funding sources and the Mobula feed) and funding.go in the hyperliquid-frontends harness (dYdX, Paradex). Point them 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 96 ms (p50, 24h) across 6 ranked venues.

**Rankings (Warm book p50, 24h):**
1. Polymarket: Warm book p50 96 ms, p99 248 ms (success 100.0%, sample 51837.1)
2. PredictIt: Warm book p50 120 ms, p99 627 ms (success 66.7%, sample 17275.2)
3. Kalshi: Warm book p50 120 ms, p99 397 ms (success 100.0%, sample 51833.5)
4. Limitless: Warm book p50 255 ms, p99 733 ms (success 100.0%, sample 51832.4)
5. Manifold: Warm book p50 269 ms, p99 978 ms (success 100.0%, sample 37019.2)
6. Myriad: Warm book p50 549 ms, p99 2.39 s (success 99.9%, sample 51804.6)

**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 94 ms (p50, 24h) across 6 ranked venues.

**Rankings (Warm price p50, 24h):**
1. Polymarket: Warm price p50 94 ms, p99 248 ms (success 100.0%, sample 51837.1)
2. Manifold: Warm price p50 112 ms, p99 582 ms (success 100.0%, sample 37020.2)
3. PredictIt: Warm price p50 120 ms, p99 627 ms (success 66.7%, sample 17275.2)
4. Kalshi: Warm price p50 124 ms, p99 397 ms (success 100.0%, sample 51832.5)
5. Limitless: Warm price p50 295 ms, p99 914 ms (success 100.0%, sample 51832.4)
6. Myriad: Warm price p50 549 ms, p99 2.39 s (success 99.9%, sample 51804.6)

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

## Resolution delay, Polymarket vs Kalshi

- Category: Trading
- Metric: Resolution delay (s)
- Page: https://openchainbench.com/benchmarks/pm-resolution-delay
- JSON: https://openchainbench.com/api/stat/pm-resolution-delay
- Status: live
- Headline: Kalshi — All and Kalshi — Sports both post the lowest resolution delay, tied at 9.5 min (p50, 24h) across 7 ranked venues.

**Rankings (p50 (median delay), 24h):**
1. Kalshi — All: p50 (median delay) 9.5 min, p99 51.3 min (success 100.0%, sample 29)
2. Kalshi — Sports: p50 (median delay) 9.5 min, p99 51.3 min (success 100.0%, sample 29)
3. Polymarket — Crypto: p50 (median delay) 10.5 min, p99 160.9 min (success 100.0%, sample 16587)
4. Polymarket — Sports: p50 (median delay) 57.8 min, p99 237.6 min (success 100.0%, sample 288195)
5. Polymarket — All: p50 (median delay) 88.0 min, p99 238.1 min (success 100.0%, sample 404191)
6. Polymarket — Other: p50 (median delay) 145.8 min, p99 239.4 min (success 100.0%, sample 93409)
7. Polymarket — Politics: p50 (median delay) 180.3 min, p99 239.7 min (success 100.0%, sample 6000)

**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 96.8% (24h avg) across 2 ranked providers.

**Rankings (p50, 24h):**
1. OpenSea: 96.8% (p99 96.8%, success 100.0%, sample 4411.53)
2. Alchemy: 94.4% (p99 94.4%, success 100.0%, sample 5997.08)

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

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

- Category: Trading
- Metric: 24h perp volume (usd)
- Page: https://openchainbench.com/benchmarks/perp-volume-share
- JSON: https://openchainbench.com/api/stat/perp-volume-share
- Status: live
- Headline: Hyperliquid leads 24h perp volume at $5.13B (24h) across 23 ranked venues.

**Rankings (p50, 24h):**
1. Hyperliquid: $5.13B (p99 $6.08B, success 100.0%, sample 2880)
2. trade.xyz: $1.42B (p99 $2.05B, success 80.0%, sample 2880)
3. Lighter: $1.33B (p99 $1.62B, success 100.0%, sample 2880)
4. Aster: $1.13B (p99 $1.36B, success 100.0%, sample 2880)
5. Kalshi: $742.97M (p99 $884.14M, success 80.0%, sample 2880)
6. Pacifica: $675.54M (p99 $788.16M, success 100.0%, sample 2880)
7. Lighter RH: $545.43M (p99 $640.42M, success 80.0%, sample 2880)
8. Extended: $456.33M (p99 $555.66M, success 98.5%, sample 2880)
9. GRVT: $434.12M (p99 $489.83M, success 83.3%, sample 2880)
10. ApeX Omni: $430.44M (p99 $434.78M, success 80.0%, sample 2880)
11. StandX: $390.35M (p99 $440.23M, success 79.9%, sample 2880)
12. Backpack: $180.09M (p99 $246.24M, success 50.0%, sample 2880)
13. Nado: $172.43M (p99 $332.13M, success 83.3%, sample 2880)
14. Ondo Perps: $137.41M (p99 $183.47M, success 80.0%, sample 2880)
15. Jupiter Perps: $128.10M (p99 $145.43M, success 80.0%, sample 2880)
16. Polymarket: $61.46M (p99 $72.81M, success 80.0%, sample 2880)
17. Orderly: $28.86M (p99 $45.30M, success 50.0%, sample 2880)
18. GMX V2: $27.24M (p99 $38.63M, success 99.8%, sample 2880)
19. Vest: $23.23M (p99 $44.25M, success 75.0%, sample 2880)
20. dYdX v4: $18.33M (p99 $44.70M, success 100.0%, sample 2880)
21. Gains: $14.66M (p99 $17.79M, success 80.0%, sample 2880)
22. Paradex: $13.66M (p99 $16.98M, success 100.0%, sample 2880)
23. Aevo: $1.77M (p99 $1.89M, success 82.8%, 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: Gains backend volume-mix API (backend-global.gains.trade), auto + direct notional per UTC day (opens and closes at full notional, resizes at traded delta, the same perimeter as DefiLlama and bench 266) over Arbitrum, Base, Polygon and MegaETH; rolling 24h = today so far plus the remaining share of yesterday.
- 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.
- Nado (the Vertex team's venue on Ink, published as Vertex until 2026-09-22): archive market_snapshots, cumulative volume per product diffed 24h apart and summed.
- Kalshi: margin/markets volume_24h_notional_value_dollars summed. Vest: /v2/ticker/24hr quoteVolume summed. StandX: summary.volume_quote_24h. ApeX Omni: turnover24h per live contract. Jupiter Perps: market-stats volume for SOL, ETH, WBTC. Lighter RH: exchangeStats daily_quote_token_volume. trade.xyz: dayNtlVlm of the xyz dex universe.
- 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: Vest posts the lowest 24h ETH funding stddev at 0.0015% (24h avg) across 14 ranked venues.

**Rankings (p50, 24h):**
1. Vest: 0.0015% (p99 0.0049%, success 100.0%, sample 2880)
2. Bitget: 0.0049% (p99 0.0080%, success 100.0%, sample 2880)
3. Paradex: 0.0051% (p99 0.014%, success 100.0%, sample 2880)
4. Gate: 0.0054% (p99 0.0037%, success 100.0%, sample 2880)
5. OKX: 0.0057% (p99 0.017%, success 100.0%, sample 2880)
6. Aster: 0.0086% (p99 0.011%, success 100.0%, sample 2880)
7. MEXC: 0.0087% (p99 0.012%, success 100.0%, sample 2880)
8. Binance: 0.011% (p99 0.0086%, success 100.0%, sample 2880)
9. ApeX Omni: 0.011% (p99 0.022%, success 100.0%, sample 2880)
10. Bybit: 0.012% (p99 0.019%, success 100.0%, sample 2880)
11. Lighter: 0.015% (p99 0.012%, success 100.0%, sample 2880)
12. KuCoin: 0.016% (p99 0.0052%, success 100.0%, sample 2880)
13. Kraken: 0.023% (p99 0.060%, success 100.0%, sample 2880)
14. dYdX v4: 0.032% (p99 0.0014%, 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. Two sources. 8 polled directly (perp_funding_hold_24h_bps): Hyperliquid, Bybit, dYdX v4, Binance, OKX, Paradex, Aster, Ondo Perps. 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.

## Ethereum RPC endpoints: free public URLs and private API-key providers by 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 has the lowest median latency of the 6 free public Ethereum RPC endpoints measured, 28 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 28 ms (p99 146 ms, success 99.5%, sample 4313.87)
2. PublicNode: 76 ms (p99 236 ms, success 100.0%, sample 4318.87)
3. Tenderly: 122 ms (p99 145 ms, success 100.0%, sample 4319.87)
4. NOWNodes: 126 ms (p99 198 ms, success 95.6%, sample 4317.87)
5. Nodies: 140 ms (p99 214 ms, success 100.0%, sample 4319.87)
6. MeowRPC: 155 ms (p99 421 ms, success 100.0%, sample 4317.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/ethereum-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/ethereum-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Ethereum RPC endpoints measured, 9 ms (p50, 24h, 3 regions).
1. GetBlock: 9 ms (p99 36 ms, success 100.0%, sample n/a)
2. QuickNode: 28 ms (p99 155 ms, success 100.0%, sample n/a)
3. Alchemy: 35 ms (p99 91 ms, success 100.0%, sample n/a)
4. Chainstack: 64 ms (p99 201 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Ethereum-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="ethereum". Provider coverage: 6 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Ethereum endpoints every 120 seconds from the same 3 regions, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 20 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

## Arbitrum RPC endpoints: free public URLs and private API-key providers by 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: dRPC has the lowest median latency of the 6 free public Arbitrum RPC endpoints measured, 63 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 63 ms (p99 165 ms, success 99.4%, sample 4315.87)
2. PublicNode: 73 ms (p99 196 ms, success 100.0%, sample 4317.87)
3. Tenderly: 105 ms (p99 118 ms, success 100.0%, sample 4319.87)
4. Arbitrum: 132 ms (p99 190 ms, success 100.0%, sample 4320.87)
5. Nodies: 137 ms (p99 168 ms, success 100.0%, sample 4319.87)
6. MeowRPC: 193 ms (p99 308 ms, success 99.8%, sample 4317.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/arbitrum-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/arbitrum-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Arbitrum RPC endpoints measured, 8 ms (p50, 24h, 3 regions).
1. GetBlock: 8 ms (p99 62 ms, success 100.0%, sample n/a)
2. QuickNode: 28 ms (p99 67 ms, success 100.0%, sample n/a)
3. Alchemy: 33 ms (p99 93 ms, success 100.0%, sample n/a)
4. Chainstack: 76 ms (p99 227 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Arbitrum-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="arbitrum". Provider coverage: 6 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Arbitrum endpoints every 120 seconds from the same 3 regions, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 20 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

## Base RPC endpoints: free public URLs and private API-key providers by 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 has the lowest median latency of the 5 free public Base RPC endpoints measured, 72 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 72 ms (p99 204 ms, success 100.0%, sample 4318.87)
2. dRPC: 79 ms (p99 180 ms, success 85.1%, sample 4319.87)
3. Tenderly: 109 ms (p99 143 ms, success 100.0%, sample 4319.87)
4. Base (Coinbase): 128 ms (p99 179 ms, success 100.0%, sample 4320.87)
5. Nodies: 137 ms (p99 210 ms, success 100.0%, sample 4318.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/base-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/base-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Base RPC endpoints measured, 7 ms (p50, 24h, 3 regions).
1. GetBlock: 7 ms (p99 46 ms, success 100.0%, sample n/a)
2. QuickNode: 27 ms (p99 80 ms, success 100.0%, sample n/a)
3. Chainstack: 30 ms (p99 244 ms, success 100.0%, sample n/a)
4. Alchemy: 34 ms (p99 103 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Base-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="base". Provider coverage: 5 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Base endpoints every 120 seconds from the same 3 regions, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 20 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

## Optimism RPC endpoints: free public URLs by 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 has the lowest median latency of the 5 free public Optimism RPC endpoints measured, 70 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 70 ms (p99 182 ms, success 100.0%, sample 4319.87)
2. dRPC: 80 ms (p99 163 ms, success 84.9%, sample 4320.87)
3. Tenderly: 106 ms (p99 118 ms, success 100.0%, sample 4319.87)
4. Nodies: 139 ms (p99 220 ms, success 100.0%, sample 4319.87)
5. Optimism: 168 ms (p99 231 ms, success 99.9%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Optimism-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="optimism". Provider coverage: 5 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Avalanche RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Avalanche RPC endpoints measured, 74 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 74 ms (p99 166 ms, success 100.0%, sample 4318.87)
2. Avalanche: 81 ms (p99 121 ms, success 100.0%, sample 4318.87)
3. Tenderly: 107 ms (p99 121 ms, success 100.0%, sample 4320.87)
4. dRPC: 179 ms (p99 443 ms, success 99.4%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Avalanche-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="avalanche". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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.

## BNB Chain RPC endpoints: free public URLs and private API-key providers by 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 has the lowest median latency of the 3 free public BNB Chain RPC endpoints measured above the 50 % success floor (4 listed), 32 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Binance: 32 ms (p99 159 ms, success 100.0%, sample 4319.87)
2. PublicNode: 73 ms (p99 199 ms, success 99.9%, sample 4317.87)
3. NOWNodes: 150 ms (p99 338 ms, success 98.6%, sample 4317.97)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/bnb-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/bnb-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) BNB Chain RPC endpoints measured, 9 ms (p50, 24h, 3 regions).
1. GetBlock: 9 ms (p99 35 ms, success 100.0%, sample n/a)
2. QuickNode: 27 ms (p99 93 ms, success 100.0%, sample n/a)
3. Alchemy: 37 ms (p99 96 ms, success 100.0%, sample n/a)
4. Chainstack: 61 ms (p99 133 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the BNB Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="bnb". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed BNB Chain endpoints every 120 seconds from the same 3 regions, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 20 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

## Polygon RPC endpoints: free public URLs and private API-key providers by 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 has the lowest median latency of the 3 free public Polygon RPC endpoints measured, 25 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 25 ms (p99 152 ms, success 100.0%, sample 4315.87)
2. Tenderly: 107 ms (p99 128 ms, success 100.0%, sample 4316.87)
3. PublicNode: 1.57 s (p99 5.29 s, success 69.7%, sample 4319.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/polygon-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/polygon-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Polygon RPC endpoints measured, 9 ms (p50, 24h, 3 regions).
1. GetBlock: 9 ms (p99 789 ms, success 100.0%, sample n/a)
2. QuickNode: 27 ms (p99 255 ms, success 100.0%, sample n/a)
3. Alchemy: 34 ms (p99 80 ms, success 100.0%, sample n/a)
4. Chainstack: 97 ms (p99 283 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Polygon-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="polygon". Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Polygon endpoints every 120 seconds from the same 3 regions, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 20 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

## Linea RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Linea RPC endpoints measured, 71 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 71 ms (p99 209 ms, success 100.0%, sample 4318.87)
2. Tenderly: 152 ms (p99 191 ms, success 100.0%, sample 4320.87)
3. dRPC: 187 ms (p99 497 ms, success 98.9%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Linea-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="linea". Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Scroll RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Scroll RPC endpoints measured, 71 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 71 ms (p99 179 ms, success 100.0%, sample 4318.87)
2. Tenderly: 152 ms (p99 215 ms, success 100.0%, sample 4320.87)
3. dRPC: 188 ms (p99 483 ms, success 98.9%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Scroll-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="scroll". Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Mantle RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/mantle-rpc
- JSON: https://openchainbench.com/api/stat/mantle-rpc
- Status: live
- Headline: PublicNode has the lowest median latency of the 3 free public Mantle RPC endpoints measured, 72 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 72 ms (p99 235 ms, success 100.0%, sample 4320.87)
2. Tenderly: 106 ms (p99 117 ms, success 100.0%, sample 4317.87)
3. dRPC: 422 ms (p99 942 ms, success 99.4%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Mantle-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="mantle". Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Perp DEX execution quality: slippage on a $100k market order, live across orderbook venues

- Category: Trading
- Metric: Slippage at $100k (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 slippage at $100k at 0.0033% (24h avg) across 9 ranked venues.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.0033% (p99 0.018%, success 99.0%, sample 2880)
2. Extended: 0.0037% (p99 0.016%, success 100.0%, sample 2880)
3. Aster: 0.0051% (p99 0.021%, success 100.0%, sample 2880)
4. Lighter: 0.0069% (p99 0.012%, success 99.7%, sample 2880)
5. edgeX: 0.0070% (p99 0.033%, success 100.0%, sample 2880)
6. Polymarket: 0.020% (p99 0.074%, success 100.0%, sample 2880)
7. Ondo Perps: 0.036% (p99 0.078%, success 100.0%, sample 2880)
8. dYdX v4: 0.064% (p99 0.20%, success 99.7%, sample 2880)
9. Paradex: 0.099% (p99 0.99%, success 100.0%, sample 2880)

**Methodology**:
- Cadence: every 30 seconds per venue and asset, 8 second timeout per fetch, from the perp-fees harness (bench 007). The metric is perp_fees_all_in_bps_tier{notional="100000"} minus perp_fees_taker_fee_bps for the same venue and asset, averaged over 24 hours.
- Mid price: (best_bid + best_ask) / 2 from the top of each book at tick time. Slippage: (size-weighted average ask price filled - mid) / mid x 10,000, so half the quoted spread is part of the number and a one-tick book reads above zero.
- Walk: levels are consumed in price order, min(level_notional_usd, remaining_target_usd) at each, until $100,000 is filled. Books capped by the venue API (Paradex 100 levels, edgeX 200 levels) skip the tier when the visible depth cannot fill it (or, on Paradex, when the walk would eat more than 90 % of the visible side) rather than publish an inflated number.
- Book endpoints, part 1: Hyperliquid POST /info l2Book; Lighter GET /api/v1/orderBookOrders (100 levels); Aster GET /fapi/v1/depth (100 levels); Extended GET /api/v1/info/markets/{market}/orderbook; dYdX v4 indexer GET /v4/orderbooks/perpetualMarket/{ticker}.
- Book endpoints, part 2: Paradex GET /orderbook/{market}/interactive (the Retail book, RPI liquidity included, see perp-fees); Ondo Perps GET /v1/perps/depth (100 levels); Polymarket perps GET /v1/info/book (500 levels); edgeX GET /api/v2/public/quote/getDepth (200 levels).
- Fee excluded on purpose: Lighter quotes 0 bps taker, Hyperliquid 4.5, Aster and dYdX 5, Extended and Ondo 2.5, Polymarket 4, edgeX 3.8, Paradex 0 on Retail orders. The all-in ranking with fees is the perp-fees bench; this page answers the depth question only.
- Oracle-priced venues excluded: GMX v2 and Gains price against an oracle with a fixed spread and impact parameter, there is no book to walk, so their tiers are flat and would read as zero or constant slippage. They stay on perp-fees where the fee and the spread parameter are counted together.
- Headline tier $100,000, tabs ETH, BTC, SOL. The $1,000, $10,000 and $1,000,000 tiers are available as raw series through perp_fees_all_in_bps_tier{notional} on the API and MCP surfaces.
- Failures: a venue that errors or returns an empty book drops perp_fees_health to 0 for that asset and increments perp_fees_fetch_errors_total{error_type}; the leaderboard tags it as stale and the 24 h average excludes the missing ticks.

## Sonic RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Sonic RPC endpoints measured, 72 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 72 ms (p99 225 ms, success 100.0%, sample 4317.87)
2. Tenderly: 107 ms (p99 122 ms, success 100.0%, sample 4316.87)
3. Sonic Labs: 112 ms (p99 2.37 s, success 100.0%, sample 4320.87)
4. dRPC: 180 ms (p99 451 ms, success 99.3%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Sonic-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="sonic". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Gnosis RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Gnosis RPC endpoints measured, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 280 ms, success 100.0%, sample 4319.87)
2. Tenderly: 106 ms (p99 118 ms, success 100.0%, sample 4319.87)
3. dRPC: 113 ms (p99 179 ms, success 99.2%, sample 4318.87)
4. Gnosis: 168 ms (p99 599 ms, success 100.0%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Gnosis-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="gnosis". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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.

## Celo RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Celo RPC endpoints measured, 73 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 73 ms (p99 255 ms, success 100.0%, sample 4318.87)
2. Celo (Forno): 109 ms (p99 376 ms, success 100.0%, sample 4318.87)
3. Tenderly: 154 ms (p99 195 ms, success 100.0%, sample 4318.87)
4. dRPC: 268 ms (p99 1.01 s, success 52.1%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Celo-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="celo". Provider coverage: 4 no-key endpoints. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Moonbeam RPC endpoints: free public URLs by 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 is the only one of the 2 free public Moonbeam RPC endpoints answering our probes, at 263 ms (p50, 24h, 3 regions).

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

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Moonbeam-scoped view of the same harness, with the same exclusion rules.

## Unichain RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Unichain RPC endpoints measured, 72 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 72 ms (p99 166 ms, success 100.0%, sample 4318.87)
2. Tenderly: 106 ms (p99 118 ms, success 100.0%, sample 4318.87)
3. dRPC: 114 ms (p99 186 ms, success 99.0%, sample 4314.87)
4. Unichain (Uniswap Labs): 132 ms (p99 160 ms, success 100.0%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Unichain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="unichain". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Blast RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Blast RPC endpoints measured, 4 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Blast: 4 ms (p99 5 ms, success 100.0%, sample 4318.87)
2. PublicNode: 71 ms (p99 166 ms, success 100.0%, sample 4318.87)
3. dRPC: 184 ms (p99 487 ms, success 99.4%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Blast-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="blast". Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Taiko RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Taiko RPC endpoints measured, 73 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 73 ms (p99 220 ms, success 100.0%, sample 4318.87)
2. Taiko: 131 ms (p99 491 ms, success 100.0%, sample 4314.87)
3. dRPC: 142 ms (p99 316 ms, success 99.4%, sample 4316.87)
4. Tenderly: 154 ms (p99 170 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Taiko-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="taiko". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Berachain RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/berachain-rpc
- JSON: https://openchainbench.com/api/stat/berachain-rpc
- Status: live
- Headline: Berachain has the lowest median latency of the 4 free public Berachain RPC endpoints measured, 57 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Berachain: 57 ms (p99 68 ms, success 100.0%, sample 4319.87)
2. PublicNode: 71 ms (p99 206 ms, success 100.0%, sample 4318.87)
3. dRPC: 144 ms (p99 264 ms, success 99.4%, sample 4316.87)
4. Tenderly: 151 ms (p99 172 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Berachain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="berachain". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## zkSync Era RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public zkSync Era RPC endpoints measured, 116 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 116 ms (p99 462 ms, success 99.4%, sample 4318.87)
2. zkSync: 133 ms (p99 516 ms, success 99.8%, sample 4315.87)
3. Tenderly: 156 ms (p99 190 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the zkSync Era-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="zksync". Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Cronos RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Cronos RPC endpoints measured, 54 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Cronos: 54 ms (p99 109 ms, success 100.0%, sample 4318.87)
2. PublicNode: 73 ms (p99 140 ms, success 99.9%, sample 4316.87)
3. dRPC: 92 ms (p99 179 ms, success 99.1%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Cronos-scoped view of the same harness, with the same exclusion rules.

## Fraxtal RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Fraxtal RPC endpoints measured, 29 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Fraxtal: 29 ms (p99 190 ms, success 100.0%, sample 4319.87)
2. PublicNode: 73 ms (p99 247 ms, success 100.0%, sample 4319.87)
3. Tenderly: 105 ms (p99 118 ms, success 100.0%, sample 4319.87)
4. dRPC: 116 ms (p99 183 ms, success 99.5%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Fraxtal-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="fraxtal". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Soneium RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Soneium RPC endpoints measured, 42 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Soneium: 42 ms (p99 69 ms, success 100.0%, sample 4318.87)
2. PublicNode: 74 ms (p99 259 ms, success 100.0%, sample 4319.87)
3. Tenderly: 106 ms (p99 120 ms, success 100.0%, sample 4319.87)
4. dRPC: 248 ms (p99 517 ms, success 68.1%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Soneium-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="soneium". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## Monad RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Monad RPC endpoints measured, 6 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Monad: 6 ms (p99 7 ms, success 100.0%, sample 4318.87)
2. OnFinality: 89 ms (p99 1.02 s, success 67.2%, sample 4319.87)
3. Tenderly Gateway: 107 ms (p99 133 ms, success 100.0%, sample 4319.87)
4. dRPC: 114 ms (p99 175 ms, success 63.5%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Monad-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="monad" (chain id 143, mainnet since November 2025). Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.

## MegaETH RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public MegaETH RPC endpoints measured, 27 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. MegaETH Official: 27 ms (p99 74 ms, success 100.0%, sample 4318.87)
2. dRPC: 88 ms (p99 188 ms, success 99.4%, sample 4318.87)
3. Tenderly Gateway: 106 ms (p99 126 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the MegaETH-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="megaeth" (chain id 4326, mainnet since February 2026). Provider coverage: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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 6 ms (p50, 24h) across 7 ranked providers.

**Rankings (p50, 24h):**
1. bloXroute Protect: 6 ms (p99 15 ms, success 99.8%, sample 60484.2)
2. 48 Club Privacy RPC: 17 ms (p99 34 ms, success 100.0%, sample 30242.1)
3. PancakeSwap MEV Guard: 40 ms (p99 50 ms, success 100.0%, sample 30242.1)
4. MEV Blocker: 113 ms (p99 135 ms, success 99.9%, sample 30242.1)
5. Blink: 122 ms (p99 145 ms, success 77.6%, sample 90726.3)
6. Flashbots Protect: 123 ms (p99 146 ms, success 83.3%, sample 30242.1)
7. BlockSec Anti-MEV: 140 ms (p99 169 ms, success 100.0%, sample 60484.2)

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

## Solana RPC endpoints: free public URLs and private API-key providers by 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 Labs has the lowest median latency of the 4 free public Solana RPC endpoints measured, 20 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Solana Labs: 20 ms (p99 397 ms, success 100.0%, sample 4318.87)
2. Solana Vibe Station: 70 ms (p99 263 ms, success 100.0%, sample 4319.87)
3. PublicNode: 73 ms (p99 140 ms, success 97.7%, sample 4316.87)
4. LeoRPC: 379 ms (p99 3.50 s, success 100.0%, sample 4315.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/solana-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/solana-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Solana RPC endpoints measured, 8 ms (p50, 24h, 3 regions).
1. GetBlock: 8 ms (p99 48 ms, success 100.0%, sample n/a)
2. QuickNode: 21 ms (p99 124 ms, success 100.0%, sample n/a)
3. Chainstack: 34 ms (p99 196 ms, success 100.0%, sample n/a)
4. Alchemy: 35 ms (p99 89 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"getSlot","params":[{"commitment":"processed"}]}`. Plain HTTP POST, identical for every endpoint, no API key in any request; the rotating id defeats body-keyed edge caches.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Solana-scoped view of the same harness, with the same exclusion rules.
- 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.
- Chain scope: every query on this page is pinned to chain="solana". Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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).
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Solana endpoints every 120 seconds from the same 3 regions, same call (getSlot, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 50 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

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

- Category: RWA
- Metric: Price deviation (bp)
- Page: https://openchainbench.com/benchmarks/tokenized-stock-peg
- JSON: https://openchainbench.com/api/stat/tokenized-stock-peg
- Status: live
- Headline: META posts the lowest price deviation at 17.2 bps (p50, 7d) across 6 ranked tokenized stocks.

**Rankings (p50, 7d):**
1. META: 17.2 bps (p99 42.5 bps, success 100.0%, sample 1949)
2. NVDA: 18.3 bps (p99 48.3 bps, success 100.0%, sample 1949)
3. MU: 41.8 bps (p99 111 bps, success 100.0%, sample 1949)
4. PLTR: 54.7 bps (p99 114 bps, success 100.0%, sample 1949)
5. AMD: 59.9 bps (p99 115 bps, success 100.0%, sample 1949)
6. AAPL: 64.5 bps (p99 138 bps, success 100.0%, sample 1949)

**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 6 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" over the last five sessions (a 24h window holds no session on a weekend and, with the gauge kept between sessions, held one frozen tick as its median until 2026-09-23); the closed series feeds the weekend-drift bench.
- Deviation: 10000 x |pool_price - reference_price| / reference_price, sampled every 60 seconds, quantiles over 24h via quantile_over_time.
- Cohort: the 6 official tokenized equities (name pattern <Company> * Robinhood Token, shared verified Stock implementation) whose USDG pool still shows arbitrage activity: NVDA, AAPL, PLTR, META, AMD, MU. GOOGL, TSLA, MSFT, AMZN and SPY were measured until their pools froze at the last swap price (no swaps for days while the reference moved), which is a dead pool, not a peg; they return when swap volume does. Pool fee tiers: 0.3% on NVDA and META, 1% on AAPL, PLTR, AMD and MU.
- 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 ran $24k to $330k when last read (2026-07-13), so a single mid-size swap can move the onchain price meaningfully off the reference until arbitrage closes it. The bench measures the size of that gap in regular hours, not the speed of its closure (the arbitrage-latency tracker was retired).
- Reading grid: an AMM price can sit anywhere inside the pool's fee band without creating an arbitrage opportunity, so a 1% fee pool resting 80 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 six 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 (a failed read deletes that asset's deviation gauge on the spot rather than freezing it, and the freshness stamp tsp_last_success_timestamp_seconds stops advancing), 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 (bp)
- Page: https://openchainbench.com/benchmarks/xstocks-peg
- JSON: https://openchainbench.com/api/stat/xstocks-peg
- Status: live
- Headline: SPYx posts the lowest price deviation at 2.30 bps (p50, 7d) across 12 ranked tokenized stocks.

**Rankings (p50, 7d):**
1. SPYx: 2.30 bps (p99 7.77 bps, success 96.7%, sample 1877)
2. NVDAx: 3.20 bps (p99 16.2 bps, success 96.7%, sample 1877)
3. TSLAx: 3.42 bps (p99 21.4 bps, success 96.7%, sample 1877)
4. QQQx: 3.95 bps (p99 11.1 bps, success 96.5%, sample 1877)
5. MSFTx: 5.79 bps (p99 18.4 bps, success 96.6%, sample 1878)
6. METAx: 6.76 bps (p99 21.8 bps, success 96.6%, sample 1878)
7. AAPLx: 7.34 bps (p99 18.3 bps, success 96.7%, sample 1875)
8. GOOGLx: 8.30 bps (p99 25.0 bps, success 96.7%, sample 1879)
9. AMZNx: 10.0 bps (p99 26.1 bps, success 96.7%, sample 1879)
10. COINx: 10.6 bps (p99 35.8 bps, success 96.7%, sample 1877)
11. HOODx: 10.9 bps (p99 29.6 bps, success 96.6%, sample 1877)
12. PLTRx: 11.6 bps (p99 34.3 bps, success 96.6%, sample 1877)

**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.0017 to 1.0059 on 2026-09-23, rising as dividends accrue in kind), so 1e8 raw units are more than one share. The harness reads scaledUiAmountConfig from each mint account every tick (one getMultipleAccounts call, Jupiter's scaledUiConfig as fallback), publishes it as tsp_scaled_multiplier, and prices nothing for a scaled mint it could not read.
- Method history: from 2026-06 to 2026-09-23 the multiplier was silently 1.0 (Jupiter moved the field the harness read) and the seven scaled rows read 17 to 59 bps high, which put every dividend payer at the bottom of the table. Samples carry method=scaled_v2 since the fix and the medians started clean.
- 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 the last five regular sessions (7d, session-gated) via quantile_over_time. Headline pins market_state="regular"; the other sessions are labelled and exported but not ranked (the weekend-drift bench covers Robinhood Chain only).
- 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 and its Yahoo reference with the Robinhood Chain tokenized stock bench (issuer label), not its on-chain leg: here an executable Jupiter quote (fee and impact in), there the Uniswap v4 pool spot (no fee). Same equity, two issuers, two legs: comparable with that and 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 (bp)
- Page: https://openchainbench.com/benchmarks/usdy-nav-basis
- JSON: https://openchainbench.com/api/stat/usdy-nav-basis
- Status: live
- Headline: Orca (Solana) and Jupiter route (Solana) both post the lowest NAV basis, tied at 17.5 bps (p50, 24h) across 2 ranked providers.

**Rankings (|Basis| 24h median, 24h):**
1. Orca (Solana): |Basis| 24h median 17.5 bps, |Basis| p90 18.5 bps, |Basis| p99 18.5 bps, |Basis| mean 17.3 bps (success 96.5%, sample 1390)
2. Jupiter route (Solana): |Basis| 24h median 17.5 bps, |Basis| p90 18.5 bps, |Basis| p99 18.5 bps, |Basis| mean 17.3 bps (success 96.6%, sample 1391)

**Methodology**:
- NAV leg: getPrice() on Ondo's RWADynamicOracle for USDY (0xA0219AA5B31e65Bc920B5b6DFb8EdF0988121De0 on Ethereum), the redemption price the issuer publishes onchain, 18 decimals, read with one eth_call a minute. The Pyth Hermes RR feed served this leg until Hermes put price updates behind a key (2026-08-26).
- Market legs, like for like: two executable prices for the same sale of 1,000 USDY into USDC (about $1,150 at the current NAV), quoted by Jupiter's public API (lite-api.jup.ag, keyless), out amount over in amount, fee and route impact included. Orca (Solana) is the quote restricted to the USDY/USDC whirlpool (the deepest genuine USDY pool); Jupiter route (Solana) is the best open route, which on 2026-09-23 filled on Manifest. USDC is taken at $1.00.
- The whirlpool's own mid price (decoded from the pool account: sqrtPrice u128 at offset 65, both mints 6 decimals) is exported as usdy_pool_mid_price_usd for reference and charts, not ranked: a pool mid against an executable quote is not a fair comparison (the mid has no fee, the quote does).
- Basis: signed, (market - NAV) / NAV x 10000. Negative = the market discounts the NAV. The ranking sorts by the 24h median of the absolute basis; the Signed column shows the live signed value. Every value query is gated on the venue's health flag, so a minute on which a leg failed contributes nothing.
- 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 price rises daily, so a naive USD peg comparison would show permanent drift. Comparing against the live oracle price removes that by construction. One chain: both venues are on Solana, where USDY's open liquidity lives.

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

- Category: RWA
- Metric: Weekend max drift (bp)
- Page: https://openchainbench.com/benchmarks/tokenized-stock-weekend-drift
- JSON: https://openchainbench.com/api/stat/tokenized-stock-weekend-drift
- Status: live
- Headline: META posts the lowest weekend max drift at 14.1 bps (latest value) across 6 ranked tokenized stocks.

**Rankings (p50, 7d):**
1. META: 14.1 bps (p99 14.1 bps, success 100.0%, sample 6)
2. AMD: 30.6 bps (p99 30.6 bps, success 100.0%, sample 6)
3. NVDA: 78.9 bps (p99 78.9 bps, success 100.0%, sample 6)
4. MU: 82.2 bps (p99 82.2 bps, success 100.0%, sample 6)
5. PLTR: 92.5 bps (p99 92.5 bps, success 100.0%, sample 6)
6. AAPL: 94.1 bps (p99 94.1 bps, success 100.0%, sample 6)

**Methodology**:
- Data source: the tokenized-stock-peg harness itself. When regular trading resumes after a gap of 40 hours or more that contains a Saturday, it reads the maximum |deviation| per symbol over that exact gap (every non-regular minute, session-gated) from Prometheus and publishes tsp_weekend_drift_bps and tsp_weekend_drift_end_unix; a symbol with no sample in the gap has its value deleted. On start it finds the last completed weekend the same way, so a restart, even mid-weekend, loses nothing.
- Session windows come from Yahoo currentTradingPeriod (holiday aware), which the harness labels every tick; the weekend gap runs from Friday's regular close (4 pm New York) through post-market, the closed nights and Monday pre-market to the regular open (9:30 am New York), about 65 hours, longer on a holiday weekend. Thanksgiving's Wednesday-to-Friday gap is over 40 hours but holds no Saturday, so it is not counted.
- Headline: the weekend the harness currently publishes (a 10-minute read, so a deleted value is gone within minutes), shown only while its end stamp (tsp_weekend_drift_end_unix) is under eight days old, so an older weekend is never shown as last weekend. The sample count is the number of weekends published in the trailing five weeks (changes of the end stamp plus one). The reference is Friday's close all weekend (Yahoo's price does not move), so the figure is the pool's own wandering.
- Cohort: the 6 tokenized equities measured by the tokenized stock peg bench (NVDA, AAPL, PLTR, META, AMD, MU). Same pool addresses, same reference, same fee tiers; the five pools that froze at their last swap (GOOGL, TSLA, MSFT, AMZN, SPY) are out of both benches until they trade again.
- Not a fair value: an AMM can rest anywhere inside its fee band without creating arbitrage (up to 100 bps from a live price on the 1 percent pools AAPL, PLTR, AMD and MU, 30 bps on the 0.3 percent pools NVDA and META), and over a weekend there is no live price to arbitrage against, so drift can exceed that band. 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) across 3 ranked providers.

**Rankings (p50, 24h):**
1. PublicNode: 0.4 ms (p99 10.24 s, success 99.5%, sample 28492.2)
2. Tenderly: 641 ms (p99 10.24 s, success 100.0%, sample 28629.8)
3. dRPC: 659 ms (p99 10.24 s, success 99.7%, sample 28560.3)

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

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

- Category: RPCs
- Metric: Reliability incidents (count)
- Page: https://openchainbench.com/benchmarks/rpc-reliability
- JSON: https://openchainbench.com/api/stat/rpc-reliability
- Status: live
- Headline: Tenderly, Base, Arbitrum and Optimism all post the lowest reliability incidents, tied at 0 (24h) across 9 ranked providers.

**Rankings (Incidents 24h, 24h):**
1. Tenderly: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 494.11)
2. Base: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 82.0182)
3. Arbitrum: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 82.0182)
4. Optimism: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 82.0182)
5. PublicNode: Incidents 24h 27, Head lag p90 0, Head lag p99 2 (success 95.3%, sample 576.128)
6. Binance: Incidents 24h 41, Head lag p90 0, Head lag p99 0 (success 50.0%, sample 82.0182)
7. MeowRPC: Incidents 24h 83, Head lag p90 5, Head lag p99 6 (success 50.0%, sample 166.037)
8. dRPC: Incidents 24h 145, Head lag p90 0.031, Head lag p99 0.523 (success 74.8%, sample 576.126)
9. Nodies: Incidents 24h 166, Head lag p90 0, Head lag p99 0 (success 66.8%, sample 494.11)

**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 49.1% (24h avg) across 9 ranked providers.

**Rankings (p50, 24h):**
1. Titan: 49.1% (p99 49.1%, success 100.0%, sample 3522.22)
2. Quasar: 17.4% (p99 17.4%, success 100.0%, sample 1244.43)
3. BuilderNet: 16.5% (p99 16.5%, success 100.0%, sample 1185.41)
4. Vanilla: 7.97% (p99 7.97%, success 100.0%, sample 571.198)
5. Eureka: 3.73% (p99 3.73%, success 100.0%, sample 267.093)
6. Other: 3.18% (p99 3.18%, success 100.0%, sample 228.079)
7. Builder+: 1.45% (p99 1.45%, success 100.0%, sample 104.036)
8. Bob The Builder: 0.49% (p99 0.49%, success 100.0%, sample 35.0122)
9. beaverbuild: 0.098% (p99 0.098%, success 100.0%, sample 7.00243)

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

## Polkadot RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Polkadot RPC endpoints measured, 49 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 49 ms (p99 995 ms, success 100.0%, sample 4317.87)
2. PublicNode: 78 ms (p99 311 ms, success 100.0%, sample 4319.87)
3. Parity: 105 ms (p99 491 ms, success 100.0%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Polkadot-scoped view of the same harness, with the same exclusion rules.
- 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.
- Chain scope: every query on this page is pinned to `chain="polkadot"`. Provider coverage today: 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.3 ms (p50, 24h) across 2 ranked providers.

**Rankings (p50, 24h):**
1. PublicNode: 0.3 ms (p99 10.24 s, success 99.4%, sample 171160)
2. dRPC: 103 ms (p99 10.24 s, success 100.0%, sample 171160)

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

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

- Category: RPCs
- Metric: Slot push lag (ms)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-solana
- JSON: https://openchainbench.com/api/stat/ws-head-latency-solana
- Status: live
- Headline: Solana posts the lowest slot push lag at 0.3 ms (p50, 24h) across 2 ranked providers.

**Rankings (p50, 24h):**
1. Solana: 0.3 ms (p99 251 ms, success 100.0%, sample 317821)
2. PublicNode: 150 ms (p99 10.24 s, success 50.1%, sample 456611)

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

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

- Category: RWA
- Metric: Yield deviation (bp)
- Page: https://openchainbench.com/benchmarks/rwa-yield-accuracy
- JSON: https://openchainbench.com/api/stat/rwa-yield-accuracy
- Status: live
- Headline: USDY posts the lowest yield deviation at 6.00 bps (30d avg) across 4 ranked tokens.

**Rankings (|Deviation| 30d, 30d):**
1. USDY: |Deviation| 30d 6.00 bps, Signed 30d 6.00 bps, Delivered 30d 363 bps, |Deviation| 7d 16.0 bps (success 100.0%, sample 24605)
2. OUSG: |Deviation| 30d 8.00 bps, Signed 30d 8.00 bps, Delivered 30d 353 bps, |Deviation| 7d 26.0 bps (success 100.0%, sample 24601)
3. SyrupUSDC: |Deviation| 30d 12.0 bps, Signed 30d 12.0 bps, Delivered 30d 511 bps, |Deviation| 7d 20.0 bps (success 100.0%, sample 24448)
4. USTB: |Deviation| 30d 13.0 bps, Signed 30d -13.0 bps, Delivered 30d 339 bps, |Deviation| 7d 16.0 bps (success 100.0%, sample 24189)

**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: NAV growth between the print in force now and the print in force 30 days ago, annualized compounded over the real time between the two prints (27 to 33 days; the span is published as rwa_yield_window_days_30d). Sources: Ondo's price oracle for USDY and OUSG (USDY's Ethereum totalSupply shrinks as holders bridge out, so a rebase read would show a negative yield), Superstate's Chainlink NAV feed for USTB, convertToAssets() on the ERC-4626 vault for SyrupUSDC.
- Promised yield: one convention for every row, the 30-day mean APY on the DefiLlama yields feed (apyMean30d), the same window as the delivered figure; a spot figure against a 30-day realized yield opens a gap that is the window's, not the fund's (the choice moved USTB by 26 bps on 2026-09-23). Read by hand and dated per entry in the harness config; the issuer's displayed APY sits in the notes. Values 2026-09-23: USDY 3.57%, OUSG 3.45%, USTB 3.52%, SyrupUSDC 4.99%.
- Windows: headline is the absolute 30-day deviation (closest tracker first); the signed 30-day figure and the 7-day absolute deviation are the next columns, both anchored on NAV prints so the figure no longer swings with the hour of sampling (USTB read 328 to 389 bps over twenty flat days before 2026-09-23). The lifetime series the harness also exposes is computed only for the dormant BUIDL adapter and is not shown.
- Sign and convention: delivered minus promised, in basis points, in the Signed 30d column; negative means the token paid less than advertised over the window. Both sides are compounded annual rates (an APY of A grows a balance by (1+A)^(days/365)); truncating a simple annualization used to cost every row 6 to 12 bps. The ranking uses the absolute value.
- 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. The 30d and 7d yields are recomputed hourly (the print search is a few dozen archive calls per token). The reference-APY config is reloaded every 60 seconds; its values are read by hand, dated per entry, refreshed best effort (2026-07-22, then 2026-09-23).
- Window edges: the feeds print once per business day, and USTB books the weekend in Monday's print, so the 30d figure moves when an edge crosses a weekend print (2026-09-23, 16:11 to 16:36 UTC: the start crossed the Aug 24 print and USTB's delivered yield went from 360 to 385 bps, the span from 33.0 to 30.0 days). Read the 30d column as a band of about plus or minus 15 bps around the fund's rate, not a point. Both anchors are real prints, so each figure is exact for the days it spans.
- 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 226 (24h) across 4 ranked providers.

**Rankings (p50, 24h):**
1. GeckoTerminal: 226 (p99 226, success 100.0%, sample 226)
2. Codex: 120 (p99 120, success 100.0%, sample 120)
3. DexPaprika: 36 (p99 36, success 100.0%, sample 36)
4. Serialized: 19 (p99 19, success 100.0%, sample 19)

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

## Osmosis RPC endpoints: free public URLs by 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: PublicNode has the lowest median latency of the 5 free public Osmosis RPC endpoints measured, 73 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 73 ms (p99 195 ms, success 100.0%, sample 4317.87)
2. Polkachu: 107 ms (p99 200 ms, success 100.0%, sample 4316.87)
3. Osmosis Foundation: 109 ms (p99 116 ms, success 100.0%, sample 4318.87)
4. LavenderFive: 133 ms (p99 235 ms, success 100.0%, sample 4317.87)
5. Imperator: 200 ms (p99 292 ms, success 97.1%, sample 4311.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Osmosis-scoped view of the same harness, with the same exclusion rules.
- 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.
- Chain scope: every query on this page is pinned to `chain="osmosis"`. Provider coverage today: 5 no-key endpoints.
- 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).

## Hyperliquid RPC endpoints: free public URLs and private API-key providers by 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: Purroof Group has the lowest median latency of the 5 free public Hyperliquid RPC endpoints measured, 125 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Purroof Group: 125 ms (p99 132 ms, success 82.5%, sample 4318.86)
2. Hyperliquid Labs: 149 ms (p99 206 ms, success 98.9%, sample 4318.87)
3. dRPC: 153 ms (p99 242 ms, success 99.4%, sample 4316.87)
4. Hypurrscan: 162 ms (p99 582 ms, success 100.0%, sample 4319.87)
5. Stakely: 360 ms (p99 1.78 s, success 99.8%, sample 4312.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/hyperliquid-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/hyperliquid-rpc?tier=keyed
- Headline: QuickNode has the lowest median latency of the 4 private (API-key) Hyperliquid RPC endpoints measured, 27 ms (p50, 24h, 3 regions).
1. QuickNode: 27 ms (p99 63 ms, success 100.0%, sample n/a)
2. Alchemy: 34 ms (p99 100 ms, success 100.0%, sample n/a)
3. GetBlock: 83 ms (p99 326 ms, success 100.0%, sample n/a)
4. Chainstack: 171 ms (p99 354 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Hyperliquid-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="hyperliquid"`. Provider coverage today: 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.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Hyperliquid endpoints every 120 seconds from the same 3 regions, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Alchemy: the Mobula enterprise-tier key; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the three probe regions, 20 CU per call.
- GetBlock regional pairing: each probe region uses GetBlock's nearest endpoint, us-east to New York, eu-west to Frankfurt, sgp to Singapore. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.

## TRON RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public TRON RPC endpoints measured, 37 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. TronGrid: 37 ms (p99 153 ms, success 100.0%, sample 4320.87)
2. PublicNode: 89 ms (p99 302 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the TRON-scoped view of the same harness, with the same exclusion rules.
- 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.
- Chain scope: every query on this page is pinned to `chain="tron"`. Provider coverage: 2 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. 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).

## Cosmos Hub RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Cosmos Hub RPC endpoints measured, 73 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 73 ms (p99 309 ms, success 100.0%, sample 4320.87)
2. Polkachu: 123 ms (p99 166 ms, success 100.0%, sample 4320.87)
3. LavenderFive: 133 ms (p99 235 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Cosmos Hub-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="cosmos-hub"`. Provider coverage today: 3 no-key endpoints.

## Injective RPC endpoints: free public URLs by 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: PublicNode has the lowest median latency of the 3 free public Injective RPC endpoints measured, 75 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 75 ms (p99 230 ms, success 100.0%, sample 4319.87)
2. Polkachu: 85 ms (p99 161 ms, success 66.1%, sample 4315.87)
3. LavenderFive: 133 ms (p99 234 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Injective-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="injective"`. Provider coverage today: 3 no-key endpoints.

## Neutron RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Neutron RPC endpoints measured, 124 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 124 ms (p99 203 ms, success 100.0%, sample 4317.87)
2. LavenderFive: 133 ms (p99 235 ms, success 99.6%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Neutron-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="neutron"`. Provider coverage today: 2 no-key endpoints.

## World Chain RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public World Chain RPC endpoints measured, 12 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. World Chain: 12 ms (p99 30 ms, success 100.0%, sample 4319.87)
2. Tenderly Gateway: 142 ms (p99 159 ms, success 100.0%, sample 4318.87)
3. dRPC: 440 ms (p99 1.35 s, success 89.4%, sample 4314.85)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the World Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="world-chain"`. Provider coverage today: 3 no-key endpoints.

## Kaia RPC endpoints: free public URLs by 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 is the only free public Kaia RPC endpoint measured, at 182 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Kaia Foundation: 182 ms (p99 207 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Kaia-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="kaia"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. dRPC removed (500 paid plan only).

## Ink RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Ink RPC endpoints measured, 68 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. QuickNode: 68 ms (p99 86 ms, success 100.0%, sample 4320.87)
2. Tenderly Gateway: 106 ms (p99 123 ms, success 100.0%, sample 4320.87)
3. Gelato: 116 ms (p99 361 ms, success 100.0%, sample 4317.87)
4. dRPC: 374 ms (p99 1.21 s, success 83.2%, sample 4317.85)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Ink-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="ink"`. Provider coverage today: 4 no-key endpoints.

## opBNB RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public opBNB RPC endpoints measured, 56 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. BNB Chain Team: 56 ms (p99 214 ms, success 100.0%, sample 4320.87)
2. PublicNode: 73 ms (p99 182 ms, success 99.9%, sample 4317.87)
3. dRPC: 506 ms (p99 1.34 s, success 83.7%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the opBNB-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="opbnb"`. Provider coverage today: 3 no-key endpoints.

## 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 3.11 s (p50, 24h) across 11 ranked providers.

**Rankings (p50, 24h):**
1. Sui: 3.11 s (p99 9.94 s, success 100.0%, sample 243.084)
2. Avalanche: 3.74 s (p99 14.02 s, success 100.0%, sample 59.0205)
3. Monad: 3.79 s (p99 12.47 s, success 100.0%, sample 101.035)
4. BNB Chain: 4.13 s (p99 13.73 s, success 100.0%, sample 1243.43)
5. Polygon: 4.46 s (p99 14.25 s, success 100.0%, sample 358.124)
6. Ink: 7.50 s (p99 9.95 s, success 100.0%, sample 7.00243)
7. Solana: 12.56 s (p99 18.24 s, success 100.0%, sample 8186.84)
8. Base: 54.00 s (p99 29.4 min, success 100.0%, sample 18.0062)
9. Ethereum: 13.8 min (p99 19.9 min, success 100.0%, sample 423.147)
10. Arbitrum: 16.6 min (p99 19.9 min, success 100.0%, sample 15.0052)
11. Celo: 17.5 min (p99 19.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 83.3% (24h avg) across 3 ranked providers.

**Rankings (Coverage rate, 24h):**
1. Jupiter: Coverage rate 83.3%, Tokens probed 24h 1,454 (success 83.3%, sample 1453.5)
2. Mobula: Coverage rate 81.9%, Tokens probed 24h 2,376 (success 81.9%, sample 2375.82)
3. KyberSwap: Coverage rate 68.8%, Tokens probed 24h 922 (success 68.8%, sample 922.32)

**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: Avalanche posts the lowest CCIP delivery at 17.34 s (p50, 24h) across 12 ranked providers.

**Rankings (p50, 24h):**
1. Avalanche: 17.34 s (p99 56.70 s, success 100.0%, sample 33.0115)
2. Berachain: 22.50 s (p99 29.85 s, success 100.0%, sample 5.00174)
3. Monad: 45.65 s (p99 2.8 min, success 100.0%, sample 24.0083)
4. Solana: 59.19 s (p99 2.0 min, success 100.0%, sample 615.214)
5. BNB Chain: 1.2 min (p99 4.5 min, success 100.0%, sample 708.246)
6. Base: 2.7 min (p99 36.9 min, success 100.0%, sample 530.184)
7. Polygon: 12.5 min (p99 14.9 min, success 100.0%, sample 24.0083)
8. Ethereum: 16.2 min (p99 19.9 min, success 100.0%, sample 109.038)
9. Robinhood Chain: 17.3 min (p99 26.9 min, success 100.0%, sample 31.0108)
10. Arbitrum: 17.4 min (p99 19.9 min, success 100.0%, sample 29.0101)
11. Optimism: 19.7 min (p99 29.8 min, success 100.0%, sample 19.0066)
12. Ink: 24.8 min (p99 38.7 min, success 100.0%, sample 26.009)

**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: Celo posts the lowest layerZero delivery at 16.50 s (p50, 24h) across 16 ranked providers.

**Rankings (p50, 24h):**
1. Celo: 16.50 s (p99 45.3 min, success 100.0%, sample 47.0163)
2. BNB Chain: 23.17 s (p99 1.9 min, success 100.0%, sample 857.298)
3. Monad: 23.86 s (p99 19.6 min, success 100.0%, sample 72.025)
4. Arbitrum: 25.17 s (p99 28.3 min, success 100.0%, sample 1294.45)
5. Robinhood Chain: 34.28 s (p99 1.9 min, success 100.0%, sample 427.148)
6. Avalanche: 36.15 s (p99 2.5 min, success 100.0%, sample 157.055)
7. Unichain: 37.50 s (p99 28.4 min, success 100.0%, sample 16.0056)
8. Solana: 45.88 s (p99 2.6 min, success 100.0%, sample 481.167)
9. Ink: 51.82 s (p99 2.0 min, success 100.0%, sample 16.0056)
10. Mantle: 52.71 s (p99 12.2 min, success 100.0%, sample 57.0198)
11. Base: 1.0 min (p99 12.2 min, success 100.0%, sample 1409.49)
12. Optimism: 1.6 min (p99 36.3 min, success 100.0%, sample 367.127)
13. Polygon: 3.1 min (p99 19.4 min, success 100.0%, sample 294.102)
14. Linea: 3.6 min (p99 9.5 min, success 100.0%, sample 32.0111)
15. Scroll: 3.7 min (p99 9.6 min, success 100.0%, sample 17.0059)
16. Ethereum: 4.1 min (p99 19.6 min, success 100.0%, sample 1206.42)

**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: Avalanche posts the lowest axelar GMP delivery at 27.00 s (p50, 24h) across 9 ranked providers.

**Rankings (p50, 24h):**
1. Avalanche: 27.00 s (p99 1.9 min, success 100.0%, sample 24.0083)
2. BNB Chain: 42.27 s (p99 1.9 min, success 100.0%, sample 64.0222)
3. Osmosis: 45.72 s (p99 2.0 min, success 100.0%, sample 251.087)
4. Polygon: 46.96 s (p99 2.0 min, success 100.0%, sample 38.0132)
5. Ethereum: 17.0 min (p99 21.3 min, success 100.0%, sample 87.0302)
6. Arbitrum: 19.4 min (p99 29.8 min, success 100.0%, sample 37.0129)
7. Optimism: 25.0 min (p99 29.9 min, success 100.0%, sample 5.00174)
8. Base: 25.2 min (p99 37.5 min, success 100.0%, sample 50.0174)
9. Celo: 26.3 min (p99 39.5 min, success 100.0%, sample 5.00174)

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

## Sei RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Sei RPC endpoints measured, 70 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Sei Labs: 70 ms (p99 279 ms, success 100.0%, sample 4318.87)
2. Stakeme: 143 ms (p99 200 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Sei-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="sei"`. Provider coverage: 2 no-key endpoints. dRPC removed (500 persistent internal error).

## Mode RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Mode RPC endpoints measured, 133 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Mode Labs: 133 ms (p99 148 ms, success 100.0%, sample 4319.87)
2. dRPC: 368 ms (p99 965 ms, success 89.3%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Mode-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="mode"`. Provider coverage today: 2 no-key endpoints.

## Ronin RPC endpoints: free public URLs by 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: Tenderly Gateway has the lowest median latency of the 2 free public Ronin RPC endpoints measured, 106 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tenderly Gateway: 106 ms (p99 125 ms, success 99.4%, sample 4314.87)
2. Sky Mavis: 129 ms (p99 210 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Ronin-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="ronin"`. Provider coverage: 2 no-key endpoints. dRPC removed (500 persistent internal error).

## Immutable zkEVM RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Immutable zkEVM RPC endpoints measured, 120 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Immutable: 120 ms (p99 174 ms, success 100.0%, sample 4320.87)
2. Tenderly Gateway: 121 ms (p99 138 ms, success 100.0%, sample 4317.87)
3. dRPC: 246 ms (p99 601 ms, success 51.1%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Immutable zkEVM-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="immutable"`. Provider coverage today: 3 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.37 s (p50, 24h) across 1 ranked venue.

**Rankings (p50, 24h):**
1. Polymarket: 1.37 s (p99 3.83 s, success 50.0%, sample 11.0042)

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

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

- Category: Blockchains
- Metric: Net yield (bps)
- Page: https://openchainbench.com/benchmarks/validator-yield-hyperliquid
- JSON: https://openchainbench.com/api/stat/validator-yield-hyperliquid
- Status: live
- Headline: infinitefield.xyz, HyperStake, CMI and Flowdex all lead on net yield, tied at 2.24% (24h avg) across 27 ranked validators.

**Rankings (p50, 24h):**
1. infinitefield.xyz: 2.24% (p99 2.24%, success 100.0%, sample 1558750000)
2. HyperStake: 2.24% (p99 2.24%, success 100.0%, sample 808922000)
3. CMI: 2.24% (p99 2.24%, success 100.0%, sample 844473000)
4. Flowdex: 2.24% (p99 2.24%, success 100.0%, sample 339522000)
5. Hypurrscanning: 2.22% (p99 2.22%, success 100.0%, sample 2163110000)
6. Alphaticks: 2.22% (p99 2.22%, success 100.0%, sample 437315000)
7. Asymmetric Research: 2.21% (p99 2.21%, success 100.0%, sample 356185000)
8. Purrposeful x HyBridge x PiP: 2.20% (p99 2.20%, success 100.0%, sample 660659000)
9. Hyperliquid Strategies x Unit: 2.20% (p99 2.20%, success 100.0%, sample 3226100000)
10. Nansen x HypurrCollective: 2.20% (p99 2.20%, success 100.0%, sample 2047770000)
11. Hyperbeat x P2P x Hypio: 2.20% (p99 2.20%, success 100.0%, sample 380214000)
12. Bitwise Onchain Solutions x FalconX: 2.18% (p99 2.18%, success 100.0%, sample 319033000)
13. Hyper Foundation 3: 2.18% (p99 2.18%, success 100.0%, sample 4816720000)
14. Hyper Foundation 2: 2.18% (p99 2.18%, success 100.0%, sample 5033050000)
15. Hyper Foundation 1: 2.18% (p99 2.18%, success 100.0%, sample 4874580000)
16. Hyper Foundation 4: 2.18% (p99 2.18%, success 100.0%, sample 3209630000)
17. Hyperdash: 2.18% (p99 2.18%, success 100.0%, sample 884934000)
18. HypurrCorea - Spacebar x DeSpread: 2.18% (p99 2.18%, success 100.0%, sample 760673000)
19. USDT0 x Luganodes: 2.18% (p99 2.18%, success 100.0%, sample 783750000)
20. Liquid Spirit x Hydromancer x Rekt Gang: 2.18% (p99 2.18%, success 100.0%, sample 413229000)
21. Enigma - Hypedexer.com X Meria: 2.18% (p99 2.18%, success 100.0%, sample 327534000)
22. Hyper Foundation 5: 2.16% (p99 2.16%, success 99.7%, sample 1410880000)
23. Kinetiq x Hyperion: 2.15% (p99 2.15%, success 100.0%, sample 567033000)
24. ValiDAO: 2.15% (p99 2.15%, success 100.0%, sample 598336000)
25. ASXN: 2.13% (p99 2.13%, success 100.0%, sample 795398000)
26. B-Harvest: 2.13% (p99 2.13%, success 100.0%, sample 472325000)
27. Anchorage By Figment: 2.02% (p99 2.02%, success 100.0%, sample 2545930000)

**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 per venue

- 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 594 (24h) across 22 ranked venues.

**Rankings (p50, 24h):**
1. Aster: 594 (p99 594, success 100.0%, sample 2880)
2. Gains: 355 (p99 355, success 80.0%, sample 2880)
3. Extended: 326 (p99 326, success 98.5%, sample 2880)
4. Aevo: 238 (p99 238, success 82.8%, sample 2880)
5. Lighter: 211 (p99 211, success 100.0%, sample 2880)
6. GRVT: 194 (p99 194, success 83.3%, sample 2880)
7. edgeX: 181 (p99 181, success 83.3%, sample 2880)
8. Hyperliquid: 178 (p99 178, success 100.0%, sample 2880)
9. ApeX Omni: 126 (p99 126, success 80.0%, sample 2880)
10. trade.xyz: 110 (p99 110, success 80.0%, sample 2880)
11. Polymarket: 88 (p99 88, success 80.0%, sample 2880)
12. Vest: 88 (p99 88, success 75.0%, sample 2880)
13. Ostium: 83 (p99 83, success 100.0%, sample 2880)
14. Pacifica: 78 (p99 78, success 100.0%, sample 2880)
15. Nado: 75 (p99 75, success 83.3%, sample 2880)
16. dYdX v4: 73 (p99 73, success 100.0%, sample 2880)
17. Ondo Perps: 65 (p99 65, success 80.0%, sample 2880)
18. Paradex: 63 (p99 63, success 100.0%, sample 2880)
19. Lighter RH: 58 (p99 58, success 80.0%, sample 2880)
20. Kalshi: 23 (p99 23, success 80.0%, sample 2880)
21. StandX: 13 (p99 13, success 79.9%, sample 2880)
22. Jupiter Perps: 3 (p99 3, success 80.0%, 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 its StarkEx-settled book.
- Aster: fapi exchangeInfo, count of instruments with contractType==PERPETUAL and status==TRADING on BNB Chain.
- Nado (the Vertex team's venue on Ink, published as Vertex until 2026-09-22): gateway /v1/symbols, count of perp products with trading_status live.
- Kalshi: margin/markets rows with status active. Vest: /v2/ticker/latest rows with status TRADING. StandX: summary.symbol_count. ApeX Omni: live perpetual and stock contracts. Jupiter Perps: markets answering market-stats. Lighter RH: active perp books on api.rh.lighter.xyz. trade.xyz: non-delisted xyz dex universe.
- 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 and GMX v2 both post the lowest cost slope ($1M / $1k), tied at 1.000x (p50, 24h) across 8 ranked venues.

**Rankings (p50, 24h):**
1. Gains: 1.000x (p99 1.000x, success 100.0%, sample 2880)
2. GMX v2: 1.000x (p99 1.000x, success 97.4%, sample 2880)
3. edgeX: 1.134x (p99 1.092x, success 100.0%, sample 2880)
4. Hyperliquid: 1.161x (p99 1.009x, success 99.0%, sample 2880)
5. Aster: 1.284x (p99 1.017x, success 100.0%, sample 2880)
6. Extended: 1.792x (p99 1.007x, success 100.0%, sample 2880)
7. dYdX v4: 2.04x (p99 1.073x, success 99.7%, sample 2880)
8. Lighter: 5.22x (p99 1.391x, success 99.7%, 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: Gains posts the lowest mark price deviation at 0.021% (p50, 24h) across 6 ranked venues.

**Rankings (p50, 24h):**
1. Gains: 0.021% (p99 0.043%, success 100.0%, sample 2880)
2. GMX v2: 0.022% (p99 0.054%, success 100.0%, sample 2880)
3. dYdX v4: 0.022% (p99 0.077%, success 99.1%, sample 2880)
4. Hyperliquid: 0.022% (p99 0.061%, success 98.0%, sample 2880)
5. Lighter: 0.049% (p99 0.072%, success 100.0%, sample 2880)
6. Paradex: 0.077% (p99 0.29%, 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): GET backend-pricing.eu.gains.trade/charts, the venue's own pricing backend (the price its front end and its trades use), BTC/USD, ETH/USD and SOL/USD pairs. A snapshot older than 60 seconds is treated as a failure, never as a price. Until 2026-09-20 the harness read a Pyth Hermes proxy instead; that endpoint went behind API keys on 2026-08-27 and the row was empty for 24 days.
- GMX v2 (oracle-priced): GET arbitrum-api.gmxinfra.io/prices/tickers, the oracle price GMX v2 publishes per token on Arbitrum; the harness uses the mid of minPrice and maxPrice, scaled from GMX's 30-decimal fixed point. Same 2026-09-20 switch from the Pyth proxy as Gains.
- 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,770 (24h) across 6 ranked venues.

**Rankings (p50, 24h):**
1. Gains: 1,770 (p99 1,770, success 100.0%, sample 2880)
2. Lighter: 1,193 (p99 1,193, success 100.0%, sample 2880)
3. dYdX v4: 1,101 (p99 1,101, success 100.0%, sample 2880)
4. Paradex: 1,101 (p99 1,101, success 100.0%, sample 2880)
5. Hyperliquid: 1,070 (p99 1,070, success 100.0%, sample 2880)
6. GMX v2: 454 (p99 454, 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.

## Kava RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Kava RPC endpoints measured, 39 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 39 ms (p99 266 ms, success 100.0%, sample 4318.87)
2. PublicNode: 74 ms (p99 221 ms, success 100.0%, sample 4318.87)
3. Kava Labs: 110 ms (p99 440 ms, success 100.0%, sample 4320.87)
4. dRPC: 176 ms (p99 499 ms, success 99.7%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Kava-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="kava"`. Provider coverage: 4 no-key endpoints.

## Zora RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Zora RPC endpoints measured, 134 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Zora Network: 134 ms (p99 236 ms, success 100.0%, sample 4319.87)
2. Conduit: 135 ms (p99 189 ms, success 100.0%, sample 4318.87)
3. dRPC: 288 ms (p99 458 ms, success 99.1%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Zora-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="zora"`. Provider coverage: 3 no-key endpoints.

## Perp DEX asset breadth: non-crypto markets live, stocks + indices + forex + 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: Hyperliquid leads non-crypto markets at 147 (24h) across 15 ranked venues.

**Rankings (p50, 24h):**
1. Hyperliquid: 147 (p99 147, success 100.0%, sample 2880)
2. Extended: 131 (p99 131, success 100.0%, sample 2880)
3. Aster: 124 (p99 124, success 100.0%, sample 2880)
4. trade.xyz: 110 (p99 110, success 100.0%, sample 2880)
5. Gains: 109 (p99 109, success 100.0%, sample 2880)
6. Vest: 75 (p99 75, success 100.0%, sample 2880)
7. Ostium: 74 (p99 74, success 100.0%, sample 2880)
8. Ondo Perps: 56 (p99 56, success 100.0%, sample 2880)
9. Lighter RH: 43 (p99 43, success 100.0%, sample 2880)
10. ApeX Omni: 40 (p99 40, success 100.0%, sample 2880)
11. Lighter: 38 (p99 38, success 100.0%, sample 2880)
12. Paradex: 21 (p99 21, success 100.0%, sample 2880)
13. GMX v2: 8 (p99 8, success 100.0%, sample 2880)
14. Kalshi: 4 (p99 4, success 100.0%, sample 2880)
15. dYdX v4: 2 (p99 2, success 100.0%, sample 2880)

**Methodology**:
- Cadence: every 60 seconds, one class count per venue per tick. Hyperliquid's HIP-3 dex list and Aster's exchangeInfo are refreshed every 10 minutes; the other catalogs are read on every tick.
- Classes: stocks (listed equities, ADRs, sector and country ETFs, pre-IPO synthetics such as OpenAI or SpaceX), indices (S&P 500, Nasdaq 100, KOSPI 200, Nikkei 225, US Treasuries, and the ETFs that track one: SPY, QQQ, IWM), forex (EUR/USD, USD/JPY, GBP/USD...), commodities (gold, silver, platinum, copper, WTI, Brent, natural gas). The ranking metric is the sum of the four; crypto is published for context in perp_venue_markets_by_class.
- Hyperliquid: POST /info perpDexs lists the HIP-3 deployer dexes, POST /info meta with dex=<name> returns each dex's universe. Core universe markets are crypto.
- Hyperliquid HIP-3 symbols: crypto when any cohort venue lists the symbol as a crypto market (the core universe, Lighter, Aster, Extended, Paradex, dYdX, Ondo; xyz:BOT is a token also listed on Lighter) or when it is a crypto index (TOTAL2, OTHERS, BTC dominance); forex, commodity or index when the fixed table says so; a stock otherwise.
- Extended: GET /api/v1/info/markets, category RWA with subCategory Equity, Commodity, FX, ETF/Index or Pre-market. ETF/Index is split per symbol (SPX500m, JP225, KR200 are indices, EWY or SOXL are sector and country ETFs and count as stocks). A Crypto-category commodity such as PAXG stays crypto.
- Aster: GET /fapi/v1/exchangeInfo underlyingSubType. STOCK counts as stocks, Commodities as commodities, ETF and USD1-RWA are split per symbol (SPXUSDT is an index, XAUUSD1 a commodity). Linear USDT and USDC pairs only.
- Paradex: GET /markets tags. RWA-tagged perps are split per symbol into commodities (XAU, XAG, XPT, XCU, CL, NG, BZ), indices (US500, US100) and stocks (the rest). Options and dated futures are excluded.
- Ostium: pair group from the Ormi subgraph (crypto, forex, stocks, etf, indices, commodities); etf is split per symbol (URA, XLE, TLT count as stocks). Pairs with a last trade price only.
- Ondo Perps: GET /v1/perps/contracts tags (Crypto, Stock, ETF, Commodity, Index, FX), enabled perpetual contracts only; ETF is split per symbol (SPY and QQQ count as indices, EWY, SOXL, URNM as stocks).
- dYdX v4: GET /v4/perpetualMarkets, ACTIVE markets. The indexer publishes no asset class and its tickers collide with the table (SPX-USD is the SPX6900 token, GME-USD a token), so a reviewed list marks EUR-USD and TRY-USD as forex, WTI-USD and XAG-USD as commodities, TSLAX-USD (xStocks TSLA) as a stock; everything else is crypto.
- Gains and Lighter: Mobula GET /api/2/perp/pairs assetClass (forex, stocks, indices, commodities count; crypto, degen and new are crypto). Mainnet chains only, arbitrum-sepolia excluded.
- GMX v2: GET arbitrum-api.gmxinfra.io/tokens, synthetic tokens matched against the table (GOLD, SILVER, WTIOIL, BRENTOIL, NATGAS are commodities, SPY and QQQ indices) plus a reviewed list for the equity synthetics the table cannot recognise (SPCX, SpaceX pre-IPO). MEGA (MegaETH) and SPX6900 stay crypto.
- A venue whose catalog call fails on a tick keeps its previous count; the per-source error counter records the failure. Counts are not sampled, so p50, p90 and p99 read the same live value.

## Abstract RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Abstract RPC endpoints measured, 151 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Abstract Foundation: 151 ms (p99 596 ms, success 100.0%, sample 4319.87)
2. dRPC: 264 ms (p99 610 ms, success 56.5%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Abstract-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="abstract"`. Provider coverage today: 2 no-key endpoints.

## ApeChain RPC endpoints: free public URLs by 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: Tenderly has the lowest median latency of the 3 free public ApeChain RPC endpoints measured, 152 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tenderly: 152 ms (p99 220 ms, success 100.0%, sample 4318.87)
2. ApeChain: 164 ms (p99 410 ms, success 100.0%, sample 4317.87)
3. dRPC: 312 ms (p99 725 ms, success 56.9%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the ApeChain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="apechain"`. Provider coverage: 3 no-key endpoints.

## Lisk RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Lisk RPC endpoints measured, 63 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 63 ms (p99 205 ms, success 99.8%, sample 4316.87)
2. Tenderly: 106 ms (p99 118 ms, success 100.0%, sample 4319.87)
3. Lisk: 149 ms (p99 597 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Lisk-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="lisk"`. Provider coverage: 3 no-key endpoints.

## Swellchain RPC endpoints: free public URLs by 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 is the only one of the 2 free public Swellchain RPC endpoints answering our probes, at 176 ms (p50, 24h, 3 regions).

**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":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Swellchain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="swellchain"`. Provider coverage: 1 no-key endpoints.

## Cyber RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Cyber RPC endpoints measured, 125 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Cyber Network: 125 ms (p99 130 ms, success 100.0%, sample 4320.87)
2. AltLayer: 135 ms (p99 157 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Cyber-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="cyber"`. Provider coverage today: 2 no-key endpoints.

## Rootstock RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Rootstock RPC endpoints measured, 135 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Rootstock Foundation: 135 ms (p99 611 ms, success 99.9%, sample 4317.87)
2. dRPC: 286 ms (p99 1.02 s, success 93.6%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Rootstock-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="rootstock"`. Provider coverage: 2 no-key endpoints.

## Metis RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Metis RPC endpoints measured, 73 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 73 ms (p99 256 ms, success 100.0%, sample 4320.87)
2. Metis: 127 ms (p99 167 ms, success 100.0%, sample 4317.87)
3. dRPC: 143 ms (p99 271 ms, success 99.4%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Metis-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="metis"`. Provider coverage: 3 no-key endpoints.

## Manta Pacific RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Manta Pacific RPC endpoints measured, 154 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Manta Network: 154 ms (p99 224 ms, success 54.2%, sample 4318.87)
2. dRPC: 442 ms (p99 1.38 s, success 57.7%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Manta Pacific-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="manta"`. Provider coverage: 2 no-key endpoints.

## Story RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Story RPC endpoints measured, 36 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 36 ms (p99 123 ms, success 100.0%, sample 4320.87)
2. Story Foundation: 37 ms (p99 69 ms, success 100.0%, sample 4318.87)
3. PublicNode: 75 ms (p99 292 ms, success 100.0%, sample 4318.87)
4. Stakely: 343 ms (p99 3.43 s, success 93.4%, sample 4314.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Story-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="story"`. Provider coverage: 4 no-key endpoints.

## Morph RPC endpoints: free public URLs by 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: QuickNode has the lowest median latency of the 3 free public Morph RPC endpoints measured, 56 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. QuickNode: 56 ms (p99 60 ms, success 100.0%, sample 4320.87)
2. dRPC: 141 ms (p99 227 ms, success 99.2%, sample 4317.87)
3. Morph: 181 ms (p99 241 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Morph-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="morph"`. Provider coverage: 3 no-key endpoints.

## Moonriver RPC endpoints: free public URLs by 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 is the only one of the 2 free public Moonriver RPC endpoints answering our probes, at 64 ms (p50, 24h, 3 regions).

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

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Moonriver-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="moonriver"`. Provider coverage: 1 no-key endpoints. UnitedBloc removed (DNS dead).

## Hemi RPC endpoints: free public URLs by 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: Hemi Labs has the lowest median latency of the 2 free public Hemi RPC endpoints measured, 104 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Hemi Labs: 104 ms (p99 185 ms, success 100.0%, sample 4319.87)
2. dRPC: 113 ms (p99 188 ms, success 99.6%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Hemi-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="hemi"`. Provider coverage: 2 no-key endpoints.

## BOB RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public BOB RPC endpoints measured, 139 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. BOB: 139 ms (p99 160 ms, success 100.0%, sample 4316.87)
2. Tenderly: 154 ms (p99 172 ms, success 100.0%, sample 4318.87)
3. dRPC: 408 ms (p99 1.04 s, success 99.4%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the BOB-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="bob"`. Provider coverage: 3 no-key endpoints.

## Polygon zkEVM RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Polygon zkEVM RPC endpoints measured, 154 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polygon zkEVM: 154 ms (p99 177 ms, success 100.0%, sample 4318.87)
2. dRPC: 263 ms (p99 555 ms, success 99.6%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Polygon zkEVM-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="polygon-zkevm"`. Provider coverage: 2 no-key endpoints.

## Arbitrum Nova RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Arbitrum Nova RPC endpoints measured, 74 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 74 ms (p99 236 ms, success 100.0%, sample 4319.87)
2. dRPC: 199 ms (p99 553 ms, success 99.3%, sample 4316.86)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Arbitrum Nova-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="arbitrum-nova"`. Provider coverage: 2 no-key endpoints.

## X Layer RPC endpoints: free public URLs by 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: dRPC has the lowest median latency of the 2 free public X Layer RPC endpoints measured, 114 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 114 ms (p99 185 ms, success 99.5%, sample 4318.87)
2. X Layer: 153 ms (p99 409 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the X Layer-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="xlayer"`. Provider coverage: 2 no-key endpoints.

## Flare RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Flare RPC endpoints measured, 21 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 21 ms (p99 228 ms, success 100.0%, sample 4319.87)
2. dRPC: 139 ms (p99 245 ms, success 99.5%, sample 4319.87)
3. Flare Foundation: 143 ms (p99 565 ms, success 99.8%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Flare-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="flare"`. Provider coverage: 3 no-key endpoints.

## Core Chain RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Core Chain RPC endpoints measured, 77 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 77 ms (p99 237 ms, success 100.0%, sample 4318.87)
2. dRPC: 117 ms (p99 203 ms, success 99.2%, sample 4317.87)
3. Core DAO: 129 ms (p99 172 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Core Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="core"`. Provider coverage: 3 no-key endpoints.

## Fuse Network RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/fuse-rpc
- JSON: https://openchainbench.com/api/stat/fuse-rpc
- Status: live
- Headline: Fuse Foundation has the lowest median latency of the 2 free public Fuse Network RPC endpoints measured, 115 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Fuse Foundation: 115 ms (p99 148 ms, success 100.0%, sample 4318.87)
2. dRPC: 237 ms (p99 504 ms, success 99.6%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches that would answer a bare head query without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Fuse Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="fuse"`. Provider coverage: 2 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 40 (24h at the average daily rate) across 12 ranked venues.

**Rankings (p50, 24h):**
1. Gains: 40 (p99 40, success 80.0%, sample 2880)
2. Aevo: 15 (p99 15, success 82.8%, sample 2880)
3. Ostium: 11 (p99 11, success 100.0%, sample 2880)
4. GRVT: 6 (p99 6, success 83.3%, sample 2880)
5. edgeX: 3 (p99 3, success 83.3%, sample 2880)
6. Pacifica: 3 (p99 3, success 100.0%, sample 2880)
7. Extended: 3 (p99 3, success 98.5%, sample 2880)
8. Paradex: 2 (p99 2, success 100.0%, sample 2880)
9. Aster: 0.750 (p99 0.750, success 100.0%, sample 2880)
10. dYdX v4: 0.674 (p99 0.674, success 100.0%, sample 2880)
11. Lighter: 0.275 (p99 0.275, success 100.0%, sample 2880)
12. Hyperliquid: 0.024 (p99 0.024, success 100.0%, 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.
- Cohort: every venue of the perp-cohort-stats harness that publishes both an active market count and a DefiLlama TVL, 12 venues as of 2026-09-22 (Gains, Hyperliquid, dYdX v4, Ostium, Aster, Extended, Lighter, Paradex, edgeX, Pacifica, Aevo, GRVT). Ondo Perps, Polymarket and Vertex have a market count but no TVL series; GMX v2 has a TVL but no native market count. The four are left out.

## Filecoin RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Filecoin RPC endpoints measured, 47 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 47 ms (p99 123 ms, success 100.0%, sample 4320.87)
2. Glif: 122 ms (p99 387 ms, success 100.0%, sample 4320.87)
3. dRPC: 267 ms (p99 978 ms, success 99.3%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Filecoin-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="filecoin"`. Provider coverage today: 3 no-key endpoints.

## Aurora RPC endpoints: free public URLs by 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 is the only free public Aurora RPC endpoint measured, at 112 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Aurora Labs: 112 ms (p99 378 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Aurora-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="aurora"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Ankr and dRPC require an API key for Aurora and have been removed.

## Bitlayer RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Bitlayer RPC endpoints measured, 146 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Bitlayer Official: 146 ms (p99 360 ms, success 100.0%, sample 4319.87)
2. dRPC: 314 ms (p99 586 ms, success 99.4%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Bitlayer-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="bitlayer"`. Provider coverage today: 2 no-key endpoints.

## 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 242 ms (p50, 24h) across 2 ranked providers.

**Rankings (p50, 24h):**
1. B² Network Official: 242 ms (p99 435 ms, success 100.0%, sample 4318.87)
2. dRPC: 352 ms (p99 777 ms, success 99.4%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the B² Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="b2"`. Provider coverage today: 2 no-key endpoints (B² Official, dRPC, Thirdweb).

## dYdX Chain RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public dYdX Chain RPC endpoints measured, 78 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 78 ms (p99 389 ms, success 100.0%, sample 4318.87)
2. Polkachu: 128 ms (p99 243 ms, success 100.0%, sample 4319.87)
3. LavenderFive: 133 ms (p99 236 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the dYdX Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="dydx"`. Provider coverage today: 3 no-key endpoints.

## Celestia RPC endpoints: free public URLs by 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: PublicNode has the lowest median latency of the 3 free public Celestia RPC endpoints measured, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 223 ms, success 100.0%, sample 4318.87)
2. Polkachu: 123 ms (p99 235 ms, success 100.0%, sample 4318.87)
3. LavenderFive: 134 ms (p99 235 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Celestia-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="celestia"`. Provider coverage today: 3 no-key endpoints.

## Boba Network RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Boba Network RPC endpoints measured, 139 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Boba Foundation: 139 ms (p99 488 ms, success 99.9%, sample 4314.87)
2. dRPC: 204 ms (p99 492 ms, success 99.4%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Boba Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="boba"`. Provider coverage: 2 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page.

## XDC Network RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public XDC Network RPC endpoints measured, 69 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 69 ms (p99 210 ms, success 100.0%, sample 4319.87)
2. XDC eRPC: 190 ms (p99 680 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the XDC Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="xdc"`. Provider coverage: 2 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. XDC Foundation official, XDCrpc and XDC.org stopped responding to probes and have been removed.

## Astar Network RPC endpoints: free public URLs by 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 is the only one of the 2 free public Astar Network RPC endpoints answering our probes, at 49 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 49 ms (p99 1.04 s, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Astar Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="astar"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. PublicNode returned 404; BlastAPI DNS is dead.

## Oasis Sapphire RPC endpoints: free public URLs by 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 is the only free public Oasis Sapphire RPC endpoint measured, at 90 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Oasis Foundation: 90 ms (p99 163 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Oasis Sapphire-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="oasis-sapphire"`. Provider coverage today: 1 no-key endpoints (Oasis Foundation).

## Oasis Emerald RPC endpoints: free public URLs by 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 is the only free public Oasis Emerald RPC endpoint measured, at 147 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Oasis Foundation: 147 ms (p99 416 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Oasis Emerald-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="oasis-emerald"`. Provider coverage today: 1 no-key endpoints (Oasis Foundation).

## Conflux eSpace RPC endpoints: free public URLs by 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 Global has the lowest median latency of the 2 free public Conflux eSpace RPC endpoints measured, 121 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Conflux Global: 121 ms (p99 238 ms, success 100.0%, sample 4316.87)
2. Conflux Foundation: 477 ms (p99 1.66 s, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Conflux eSpace-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="conflux"`. Provider coverage today: 2 no-key endpoints.

## IoTeX RPC endpoints: free public URLs by 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 is the only one of the 2 free public IoTeX RPC endpoints answering our probes, at 110 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. IoTeX Mirror: 110 ms (p99 154 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the IoTeX-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="iotex"`. Provider coverage today: 1 no-key endpoints.

## Harmony ONE RPC endpoints: free public URLs by 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 is the only free public Harmony ONE RPC endpoint measured, at 133 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Harmony S0: 133 ms (p99 409 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Harmony ONE-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="harmony"`. Provider coverage today: 1 no-key endpoints (Harmony S0).

## Zircuit RPC endpoints: free public URLs by 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 is the only free public Zircuit RPC endpoint measured, at 140 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Zircuit Foundation: 140 ms (p99 155 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Zircuit-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="zircuit"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page.

## Vana RPC endpoints: free public URLs by 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 is the only free public Vana RPC endpoint measured, at 55 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Vana Foundation: 55 ms (p99 60 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Vana-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="vana"`. Provider coverage today: 1 no-key endpoints (Vana Foundation).

## Gravity Alpha RPC endpoints: free public URLs by 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 is the only free public Gravity Alpha RPC endpoint measured, at 139 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Gravity Foundation: 139 ms (p99 156 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Gravity Alpha-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="gravity"`. Provider coverage today: 1 no-key endpoints.

## Reya Network RPC endpoints: free public URLs by 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 is the only one of the 2 free public Reya Network RPC endpoints answering our probes, at 152 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Reya Foundation: 152 ms (p99 172 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Reya Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="reya"`. Provider coverage today: 1 no-key endpoints.

## Akash Network RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Akash Network RPC endpoints measured, 74 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 74 ms (p99 249 ms, success 100.0%, sample 4318.87)
2. Polkachu: 124 ms (p99 203 ms, success 100.0%, sample 4317.87)
3. Ecostake: 151 ms (p99 309 ms, success 100.0%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Akash Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="akash"`. Provider coverage today: 3 no-key endpoints.

## Stride RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Stride RPC endpoints measured, 125 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 125 ms (p99 235 ms, success 100.0%, sample 4318.87)
2. LavenderFive: 135 ms (p99 237 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Stride-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="stride"`. Provider coverage today: 2 no-key endpoints.

## Juno RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Juno RPC endpoints measured, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 251 ms, success 100.0%, sample 4319.87)
2. Polkachu: 123 ms (p99 232 ms, success 100.0%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Juno-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="juno"`. Provider coverage today: 2 no-key endpoints.

## Axelar RPC endpoints: free public URLs by 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: PublicNode has the lowest median latency of the 3 free public Axelar RPC endpoints measured, 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 79 ms (p99 317 ms, success 100.0%, sample 4318.87)
2. Polkachu: 109 ms (p99 206 ms, success 100.0%, sample 4315.87)
3. LavenderFive: 132 ms (p99 234 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Axelar-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="axelar"`. Provider coverage today: 3 no-key endpoints.

## Dymension RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Dymension RPC endpoints measured, 126 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 126 ms (p99 244 ms, success 100.0%, sample 4319.87)
2. LavenderFive: 132 ms (p99 234 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Dymension-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="dymension"`. Provider coverage today: 2 no-key endpoints.

## Persistence RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Persistence RPC endpoints measured, 123 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 123 ms (p99 232 ms, success 100.0%, sample 4317.87)
2. Persistence Foundation: 131 ms (p99 387 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Persistence-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="persistence"`. Provider coverage today: 2 no-key endpoints.

## Coreum RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Coreum RPC endpoints measured, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 236 ms, success 100.0%, sample 4318.87)
2. Coreum Foundation: 335 ms (p99 436 ms, success 91.3%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Coreum-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="coreum"`. Provider coverage today: 2 no-key endpoints.

## Nolus RPC endpoints: free public URLs by 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 is the only free public Nolus RPC endpoint measured, at 123 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 123 ms (p99 234 ms, success 100.0%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Nolus-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="nolus"`. Provider coverage today: 1 no-key endpoints.

## Archway RPC endpoints: free public URLs by 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: LavenderFive has the lowest median latency of the 2 free public Archway RPC endpoints measured, 130 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. LavenderFive: 130 ms (p99 202 ms, success 100.0%, sample 4319.87)
2. Archway Foundation: 157 ms (p99 218 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Archway-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="archway"`. Provider coverage today: 2 no-key endpoints.

## Nibiru RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Nibiru RPC endpoints measured, 90 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Nibiru Foundation: 90 ms (p99 281 ms, success 100.0%, sample 4317.87)
2. Polkachu: 124 ms (p99 239 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Nibiru-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="nibiru"`. Provider coverage today: 2 no-key endpoints.

## Terra RPC endpoints: free public URLs by 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: PublicNode has the lowest median latency of the 3 free public Terra RPC endpoints measured, 77 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 77 ms (p99 248 ms, success 100.0%, sample 4318.87)
2. LavenderFive: 122 ms (p99 205 ms, success 99.2%, sample 4320.87)
3. Polkachu: 125 ms (p99 211 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Terra-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="terra"`. Provider coverage today: 3 no-key endpoints.

## Regen Network RPC endpoints: free public URLs by 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 is the only free public Regen Network RPC endpoint measured, at 126 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 126 ms (p99 245 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Regen Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="regen"`. Provider coverage today: 1 no-key endpoints.

## Comdex RPC endpoints: free public URLs by 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 is the only free public Comdex RPC endpoint measured, at 112 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. STAVR: 112 ms (p99 119 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Comdex-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="comdex"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page.

## Fantom RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Fantom RPC endpoints measured, 111 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Fantom Foundation: 111 ms (p99 150 ms, success 100.0%, sample 4318.87)
2. dRPC: 142 ms (p99 228 ms, success 99.3%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Fantom-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="fantom"`. Provider coverage today: 2 no-key endpoints (Fantom Foundation, dRPC, Ankr, Thirdweb, Blast API).

## Kusama RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Kusama RPC endpoints measured, 49 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 49 ms (p99 973 ms, success 100.0%, sample 4318.87)
2. PublicNode: 76 ms (p99 303 ms, success 100.0%, sample 4319.87)
3. dRPC: 456 ms (p99 674 ms, success 99.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"chain_getHeader","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Kusama-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="kusama"`. Provider coverage today: 3 no-key endpoints.

## Hydration RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Hydration RPC endpoints measured, 148 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Hydration: 148 ms (p99 475 ms, success 100.0%, sample 4312.87)
2. Dwellir: 447 ms (p99 514 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"chain_getHeader","params":[]}. Plain HTTP POST. Substrate JSON-RPC.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Hydration-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=hydration. Provider coverage today: 2 endpoints (Hydration official, Dwellir).

## HAQQ Network RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public HAQQ Network RPC endpoints measured, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 240 ms, success 100.0%, sample 4319.87)
2. HAQQ Foundation: 99 ms (p99 305 ms, success 100.0%, sample 4314.87)
3. dRPC: 217 ms (p99 559 ms, success 99.6%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the HAQQ Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="haqq"`. Provider coverage today: 3 no-key endpoints.

## Etherlink RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Etherlink RPC endpoints measured, 18 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Etherlink Foundation: 18 ms (p99 77 ms, success 100.0%, sample 4318.87)
2. dRPC: 205 ms (p99 703 ms, success 96.6%, sample 4317.86)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Etherlink-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="etherlink"`. Provider coverage today: 2 no-key endpoints.

## Chiliz Chain RPC endpoints: free public URLs by 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: Ankr has the lowest median latency of the 3 free public Chiliz Chain RPC endpoints measured, 65 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 65 ms (p99 137 ms, success 100.0%, sample 4320.87)
2. PublicNode: 75 ms (p99 153 ms, success 100.0%, sample 4318.87)
3. Chiliz Foundation: 98 ms (p99 349 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Chiliz Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="chiliz"`. Provider coverage today: 3 no-key endpoints.

## WEMIX RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public WEMIX RPC endpoints measured, 116 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 116 ms (p99 209 ms, success 99.4%, sample 4316.87)
2. WeMade: 212 ms (p99 637 ms, success 66.7%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the WEMIX-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="wemix"`. Provider coverage today: 2 no-key endpoints.

## Songbird RPC endpoints: free public URLs by 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 is the only free public Songbird RPC endpoint measured, at 143 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Flare Foundation: 143 ms (p99 571 ms, success 99.3%, sample 4318.91)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Songbird-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="songbird"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. FTSO AU removed after DNS went dead.

## Cronos zkEVM RPC endpoints: free public URLs by 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) has the lowest median latency of the 2 free public Cronos zkEVM RPC endpoints measured, 164 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Cronos (Crypto.com): 164 ms (p99 1.49 s, success 100.0%, sample 4318.87)
2. dRPC: 298 ms (p99 641 ms, success 98.7%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Cronos zkEVM-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="cronos-zkevm"`. Provider coverage today: 2 no-key endpoints.

## Ethereum Classic RPC endpoints: free public URLs by 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 is the only free public Ethereum Classic RPC endpoint measured, at 271 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 271 ms (p99 782 ms, success 99.3%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Ethereum Classic-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="ethereum-classic"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. ETCDesktop and ETCMC stopped responding to probes and have been removed.

## Telos EVM RPC endpoints: free public URLs by 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 is the only free public Telos EVM RPC endpoint measured, at 194 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 194 ms (p99 515 ms, success 63.6%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Telos EVM-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="telos"`. Provider coverage: 1 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Telos Foundation official returned 404 and has been removed.

## PulseChain RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public PulseChain RPC endpoints measured, 75 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 75 ms (p99 215 ms, success 100.0%, sample 4319.87)
2. G4MM4: 123 ms (p99 2.67 s, success 95.0%, sample 4317.87)
3. PulseChain Foundation: 133 ms (p99 350 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the PulseChain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="pulsechain"`. Provider coverage today: 3 no-key endpoints.

## Warden Protocol RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Warden Protocol RPC endpoints measured, 84 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 84 ms (p99 303 ms, success 100.0%, sample 4318.87)
2. Warden Foundation: 110 ms (p99 303 ms, success 100.0%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Warden Protocol-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="warden"`. Provider coverage today: 2 no-key endpoints.

## Oraichain RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Oraichain RPC endpoints measured, 77 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 77 ms (p99 247 ms, success 100.0%, sample 4319.87)
2. Orai Foundation: 127 ms (p99 244 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: Tendermint/CometBFT `status` JSON-RPC call. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Oraichain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="oraichain"`. Provider coverage today: 2 no-key endpoints.

## Peaq Network RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Peaq Network RPC endpoints measured, 49 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 49 ms (p99 1.07 s, success 100.0%, sample 4317.87)
2. PublicNode: 71 ms (p99 197 ms, success 100.0%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"chain_getHeader","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Peaq Network-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to `chain="peaq"`. Provider coverage today: 2 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 $163.44M (24h) across 8 ranked providers.

**Rankings (p50, 24h):**
1. PumpFun: $163.44M (p99 $163.44M, success 100.0%, sample 3537850)
2. Meteora DBC: $31.05M (p99 $31.05M, success 100.0%, sample 1145910)
3. Flap: $26.64M (p99 $26.64M, success 100.0%, sample 403364)
4. Bankr: $1.06M (p99 $1.06M, success 100.0%, sample 9934)
5. NOXA Fun: $1.05M (p99 $1.05M, success 100.0%, sample 14268)
6. Raydium Launchlab: $684.8K (p99 $684.8K, success 100.0%, sample 23467)
7. LetsCash: $63.4K (p99 $63.4K, success 100.0%, sample 635)
8. dontblink: $10.0K (p99 $10.0K, success 100.0%, sample 137)

**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: what GMGN, Axiom, FOMO and Terminal route and what they charge

- Category: Trading
- Metric: Daily volume (usd)
- Page: https://openchainbench.com/benchmarks/solana-trading-platform-wars
- JSON: https://openchainbench.com/api/stat/solana-trading-platform-wars
- Status: live
- Headline: FOMO leads daily volume at $133.89M (24h) across 7 ranked providers.

**Rankings (Volume, 24h):**
1. FOMO: Volume $133.89M (success 100.0%, sample 131)
2. Axiom: Volume $131.99M (success 100.0%, sample 129)
3. GMGN: Volume $98.20M (success 100.0%, sample 1088)
4. pump.fun app: Volume $21.03M (success 100.0%, sample 137)
5. Terminal: Volume $17.58M (success 100.0%, sample 126)
6. Trojan: Volume $3.91M (success 100.0%, sample 126)
7. Photon: Volume $1.32M (success 100.0%, sample 153)

**Methodology**:
- Source: DeFiLlama's open dexs and fees adapters, read hourly from the free summary endpoints. Both legs are per UTC day and the current open day is dropped.
- Volume: /summary/dexs/<slug>?dataType=dailyVolume, summed over every chain the adapter covers. This bench read third-party Dune datasets until 2026-09-27; they froze on 2026-08-25 and were served as current for 32 days, which is why the source is now one with a maintained adapter behind it.
- Commission: /summary/fees/<slug>?dataType=dailyRevenue, the app's own cut net of referral and cashback paybacks. Not dailyFees, which adds what the venue underneath charges: for Axiom on 2026-09-26 that reads 2.27M against 1.38M of revenue. A day returned as zero against real volume is treated as an artifact and the newest day with a positive cut is used instead.
- Take rate: commission divided by the volume of the same days, so the two halves describe the same trades. It is the app's own margin, not the price of a swap: DeFiLlama's revenue is net of referral and cashback paybacks, so an app that rebates a third of its fee reads a third lower while its traders pay the same. Ranking it higher rewards the larger margin, which is what this bench is about.
- Day anchoring: every figure for an app ends on that app's own latest closed day, not on a shared cohort day. An adapter more than 3 days behind snaps back to the cohort day and reads unresponsive; a window it can no longer fill to 80% coverage goes absent with it.
- The commission can trail the volume by up to 3 days, because a fees adapter sometimes runs behind its dexs one. It ends on the newest day that has both legs, so the take rate always divides figures from the same day; dune_platform is no longer involved and trading_app_revenue_day_unix carries the day.
- Cohort: the seven apps this bench ranks, each with both a dexs and a fees adapter on DeFiLlama. Others have both too and sit in bench 267 instead, which is the whole cohort. BasedBot has neither and left the table on 2026-09-27; it was unmeasured before that too.
- Cross-check against our own Solana SQL for 2026-09-26: Trojan +0.1%, Terminal +1.4%, Photon +4.9% on volume, and Axiom -2.3%, Photon -0.7% on commission. GMGN and FOMO read higher here because this counts every chain and every Relay leg.

## 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 (24h) across 11 ranked providers.

**Rankings (Rating, 24h):**
1. Fomo: Rating 4.80x (success 100.0%, sample 23794)
2. Kraken: Rating 4.74x (success 100.0%, sample 35504)
3. PumpFun: Rating 4.73x (success 100.0%, sample 3603)
4. Bybit: Rating 4.69x (success 100.0%, sample 46930)
5. Coinbase: Rating 4.68x (success 100.0%, sample 1797680)
6. Crypto.com: Rating 4.66x (success 100.0%, sample 334998)
7. Robinhood: Rating 4.30x (success 100.0%, sample 4867710)
8. Invo: Rating 4.24x (success 100.0%, sample 458)
9. Moonshot: Rating 4.23x (success 100.0%, sample 28741)
10. Binance.US: Rating 4.21x (success 100.0%, sample 111065)
11. GMGN: Rating 3.65x (success 100.0%, sample 97)

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

## Solana 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 $184.20M (24h) across 7 ranked providers.

**Rankings (24h Volume, 24h):**
1. pump.fun: 24h Volume $184.20M (success 100.0%, sample n/a)
2. Fomo: 24h Volume $133.22M (success 100.0%, sample n/a)
3. Axiom: 24h Volume $124.06M (success 100.0%, sample n/a)
4. GMGN: 24h Volume $32.59M (success 100.0%, sample n/a)
5. Trojan: 24h Volume $3.91M (success 100.0%, sample n/a)
6. Photon: 24h Volume $1.32M (success 100.0%, sample n/a)
7. BullX: 24h Volume $1.19M (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 measures Fomo on Solana, where user balances are held, and includes cross-chain trades routed through Relay (each counted once); its revenue combines on-chain fee-wallet inflows with relay fees the Fomo team reports. The two perimeters differ, so revenue divided by volume is not Fomo's 0.5% fee either. 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.
- Volume is a floor by DeFiLlama's own methodology: its terminal adapters (Axiom, GMGN, Trojan, Photon, BullX) count a swap when the transaction pays the terminal's fee wallet and Dune's dex_solana.trades decodes the venue, so a swap through an undecoded venue pays the fee and adds no volume. How much is missing is not something this bench can measure, and the adapters keep decoding more: days from Sep 15-17 2026 have been restated upward since.
- No take rate column, for noise rather than bias. Axiom's revenue over volume moved between 0.37% and 1.07% over Sep 13-26 2026 against a stated fee of about 1%, which is too unsteady to rank a board on. The 1.2-2.9% this bullet used to cite no longer reproduces: the same days now read 0.51-0.74%. The harness still exports defillama_dex_take_rate, and bench 201 publishes a daily take rate.
- 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, also live on BNB and Robinhood Chain (Solana volume only here). Charges about 1% per swap, tiered down with volume. 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, 0.5% 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.

## Starknet RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/starknet-rpc
- JSON: https://openchainbench.com/api/stat/starknet-rpc
- Status: live
- Awaiting samples.

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"starknet_blockNumber","params":[]}. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the rotating id defeats edge caches.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Starknet-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=starknet. Provider coverage today: 2 no-key endpoints (dRPC, Lava, Nethermind, OnFinality, 1RPC).

## Stellar Soroban RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/stellar-rpc
- JSON: https://openchainbench.com/api/stat/stellar-rpc
- Status: live
- Headline: Gateway.fm has the lowest median latency of the 5 free public Stellar Soroban RPC endpoints measured, 143 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Gateway.fm: 143 ms (p99 198 ms, success 100.0%, sample 4319.87)
2. OnFinality: 191 ms (p99 486 ms, success 91.9%, sample 4319.87)
3. Lightsail Network: 195 ms (p99 374 ms, success 100.0%, sample 4319.87)
4. SorobanRPC.com: 198 ms (p99 356 ms, success 100.0%, sample 4314.87)
5. Ankr: 631 ms (p99 1.85 s, success 99.9%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Stellar Soroban-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=stellar. Provider coverage today: 5 no-key Soroban endpoints.

## Sui RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/sui-rpc
- JSON: https://openchainbench.com/api/stat/sui-rpc
- Status: live
- Headline: OnFinality has the lowest median latency of the 4 free public Sui RPC endpoints measured, 65 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 65 ms (p99 1.09 s, success 100.0%, sample 4320.87)
2. PublicNode: 71 ms (p99 213 ms, success 100.0%, sample 4318.87)
3. Suiet: 112 ms (p99 145 ms, success 100.0%, sample 4320.87)
4. BlockVision: 167 ms (p99 2.98 s, success 83.5%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Sui-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=sui. Provider coverage today: 4 no-key endpoints.

## Aptos RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Aptos RPC endpoints measured, 41 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Aptos Labs: 41 ms (p99 127 ms, success 100.0%, sample 4320.87)
2. Aptos Labs (Fullnode): 42 ms (p99 161 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET to <base>/v1/ with Accept: application/json. Pure REST endpoint, no API key in any request. The response JSON includes block_height (decimal string) and ledger_version.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Aptos-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=aptos. Provider coverage today: 2 no-key endpoints (Aptos Labs api, Aptos Labs fullnode).

## XRP Ledger RPC endpoints: free public URLs by 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 is the only one of the 2 free public XRP Ledger RPC endpoints measured above the 50 % success floor, at 577 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ripple: 577 ms (p99 1.03 s, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the XRP Ledger-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=xrp. Provider coverage today: 2 no-key endpoints.

## Algorand RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Algorand RPC endpoints measured, 30 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 30 ms (p99 256 ms, success 75.8%, sample 4316.87)
2. AlgoNode: 67 ms (p99 94 ms, success 100.0%, sample 4319.87)
3. Nodely: 69 ms (p99 193 ms, success 100.0%, sample 4315.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET to <base>/v2/status with Accept: application/json. Pure REST endpoint, no API key in any request. The response JSON includes last-round (integer round number).
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Algorand-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=algorand. Provider coverage today: 3 no-key endpoints.

## Gram RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Gram RPC endpoints measured, 47 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 47 ms (p99 219 ms, success 75.1%, sample 4311.86)
2. TON Center: 108 ms (p99 320 ms, success 100.0%, sample 4320.87)
3. OnFinality: 190 ms (p99 1.25 s, success 99.4%, sample 4313.87)
4. Uniblock: 464 ms (p99 2.98 s, success 52.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Gram-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=gram. Provider coverage today: 4 endpoints.

## NEAR RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public NEAR RPC endpoints measured, 36 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. FastNEAR: 36 ms (p99 109 ms, success 100.0%, sample 4318.87)
2. dRPC: 104 ms (p99 239 ms, success 99.1%, sample 4318.87)
3. NEAR Foundation: 3.03 s (p99 3.11 s, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"block","params":{"finality":"final"}}. Plain HTTP POST. The response carries result.header.height as a decimal uint64.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the NEAR-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=near. Provider coverage today: 3 endpoints.

## Flow RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/flow-rpc
- JSON: https://openchainbench.com/api/stat/flow-rpc
- Status: live
- Headline: Flow Access Node has the lowest median latency of the 2 free public Flow RPC endpoints measured, 29 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Flow Access Node: 29 ms (p99 108 ms, success 100.0%, sample 4317.87)
2. Flow Foundation: 30 ms (p99 111 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET to <base>/v1/blocks?height=sealed with Accept: application/json. Pure REST endpoint, no API key. The response is a JSON array; [0].header.height is parsed as a decimal string.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Flow-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=flow. Provider coverage today: 2 endpoints (Flow Foundation REST, Flow access node).

## Hedera RPC endpoints: free public URLs by 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 is the only one of the 2 free public Hedera RPC endpoints answering our probes, at 159 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Hashio: 159 ms (p99 588 ms, success 100.0%, sample 4314.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0; Hedera's Hashio layer is EVM-compatible.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Hedera-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=hedera. Provider coverage today: 1 endpoints.

## Nervos CKB RPC endpoints: free public URLs by 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: Nervos Foundation has the lowest median latency of the 2 free public Nervos CKB RPC endpoints measured, 152 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Nervos Foundation: 152 ms (p99 990 ms, success 99.9%, sample 4315.87)
2. CKBapp: 167 ms (p99 504 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"get_tip_block_number","params":[]}. Plain HTTP POST. The result field is a hex-encoded block number string (0x prefix).
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Nervos CKB-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=ckb. Provider coverage today: 2 endpoints.

## MultiversX RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public MultiversX RPC endpoints measured, 89 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. MultiversX Gateway: 89 ms (p99 294 ms, success 100.0%, sample 4318.87)
2. Elrond API: 109 ms (p99 334 ms, success 99.0%, sample 4315.87)
3. MultiversX API: 112 ms (p99 170 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET to <base>/network/status/4294967295 with Accept: application/json. The shard ID 4294967295 (0xFFFFFFFF) is the MultiversX metachain identifier. The response carries data.status.erd_nonce as a decimal uint64.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the MultiversX-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=multiversx. Provider coverage today: 3 endpoints.

## NEO N3 RPC endpoints: free public URLs by 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: NSPCC has the lowest median latency of the 3 free public NEO N3 RPC endpoints measured, 95 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. NSPCC: 95 ms (p99 588 ms, success 100.0%, sample 4318.87)
2. NGD (2): 145 ms (p99 595 ms, success 100.0%, sample 4318.87)
3. NGD: 146 ms (p99 596 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"getblockcount","params":[]}. Plain HTTP POST. The result is a decimal integer (block count = current height + 1).
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the NEO N3-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=neo. Provider coverage today: 3 endpoints (NSPCC, NGD seed 1, NGD seed 2).

## Tezos RPC endpoints: free public URLs by 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 has the lowest median latency of the 4 free public Tezos RPC endpoints measured, 96 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. TezBeta: 96 ms (p99 401 ms, success 100.0%, sample 4318.87)
2. SmartPy: 146 ms (p99 3.61 s, success 92.4%, sample 4315.87)
3. TzKT (Baking Bad): 209 ms (p99 722 ms, success 100.0%, sample 4319.87)
4. TCInfra: 245 ms (p99 332 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: 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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Tezos-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=tezos. Provider coverage today: 4 endpoints (SmartPy, TezBeta, TzKT, TCInfra).

## EOS RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public EOS RPC endpoints measured, 116 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. EOS Nation: 116 ms (p99 581 ms, success 99.9%, sample 4315.87)
2. Greymass: 126 ms (p99 185 ms, success 100.0%, sample 4319.87)
3. Aloha EOS: 424 ms (p99 533 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET /v1/chain/get_info. Plain REST call. The response carries head_block_num as a plain integer.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the EOS-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=eos. Provider coverage today: 3 endpoints.

## VeChain RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public VeChain RPC endpoints measured, 97 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. VeChain Foundation: 97 ms (p99 423 ms, success 99.9%, sample 4318.87)
2. VeThor Node: 97 ms (p99 429 ms, success 99.9%, sample 4319.87)
3. VeChain.energy: 215 ms (p99 411 ms, success 99.9%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET /blocks/best. Plain REST call. The response carries number as a plain unsigned integer.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the VeChain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=vechain. Provider coverage today: 3 endpoints (VeChain Foundation x2, VeChain.energy).

## Waves RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Waves RPC endpoints measured, 126 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Waves.Exchange: 126 ms (p99 324 ms, success 100.0%, sample 4317.87)
2. Waves Exchange Node: 126 ms (p99 353 ms, success 100.0%, sample 4317.87)
3. Waves Foundation: 133 ms (p99 429 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET /blocks/last. Plain REST call. The response carries height as a plain integer.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Waves-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=waves. Provider coverage today: 3 endpoints (Waves Foundation, Waves.Exchange x2).

## WAX RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public WAX RPC endpoints measured, 102 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Greymass: 102 ms (p99 149 ms, success 100.0%, sample 4319.87)
2. EOSUSA: 131 ms (p99 370 ms, success 100.0%, sample 4319.87)
3. WAX Sweden: 291 ms (p99 440 ms, success 100.0%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: HTTP GET /v1/chain/get_info. Plain REST call. The response carries head_block_num as a plain integer.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the WAX-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=wax. Provider coverage today: 3 endpoints.

## Merlin Chain RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Merlin Chain RPC endpoints measured, 151 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Merlin Official: 151 ms (p99 181 ms, success 100.0%, sample 4316.87)
2. dRPC: 337 ms (p99 718 ms, success 80.2%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Merlin Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=merlin. Provider coverage today: 2 endpoints.

## Viction RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Viction RPC endpoints measured, 63 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 63 ms (p99 140 ms, success 99.3%, sample 4317.87)
2. Viction Official: 155 ms (p99 768 ms, success 100.0%, sample 4314.87)
3. Viction RPC2: 164 ms (p99 963 ms, success 100.0%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Viction-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=viction. Provider coverage today: 3 endpoints.

## OKTC RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public OKTC RPC endpoints measured, 166 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OKX Chain Official: 166 ms (p99 452 ms, success 100.0%, sample 4318.87)
2. dRPC: 349 ms (p99 628 ms, success 92.5%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}. Plain HTTP POST. Standard Ethereum JSON-RPC 2.0.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the OKTC-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=oktc. Provider coverage today: 2 endpoints.

## 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 $675.54M (24h) across 5 ranked venues.

**Rankings (p50, 24h):**
1. Pacifica: $675.54M (p99 $788.16M, success 100.0%, sample 2880)
2. GMX V2: $27.24M (p99 $38.63M, success 99.8%, sample 2880)
3. Gains: $14.66M (p99 $17.79M, success 80.0%, sample 2880)
4. KiloEx: $11.76M (p99 $14.90M, success 50.0%, sample 2880)
5. Ostium: $1.72M (p99 $2.36M, success 100.0%, 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: Gains backend volume-mix API (backend-global.gains.trade), auto + direct notional per UTC day (opens and closes at full notional, resizes at traded delta, the same perimeter as DefiLlama and bench 266) over Arbitrum, Base, Polygon and MegaETH; rolling 24h = today so far plus the remaining share of yesterday.
- 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, Lighter, 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 1.316x (24h) across 9 ranked protocols.

**Rankings (p50, 24h):**
1. GNS: 1.316x (p99 1.316x, success 100.0%, sample 2880)
2. GMX: 5.14x (p99 5.14x, success 100.0%, sample 2880)
3. F: 12.3x (p99 12.3x, success 100.0%, sample 2880)
4. JUP: 31.3x (p99 31.3x, success 100.0%, sample 2880)
5. DYDX: 42.5x (p99 42.5x, success 100.0%, sample 2880)
6. APEX: 52.2x (p99 52.2x, success 100.0%, sample 2880)
7. LIT: 74.5x (p99 74.5x, success 100.0%, sample 2880)
8. DRV: 91.1x (p99 91.1x, success 100.0%, sample 2880)
9. HYPE: 101.9x (p99 101.9x, success 100.0%, sample 2880)

**Methodology**:
- Revenue source: DeFiLlama dailyRevenue (protocol revenue accruing to treasury/holders, not total user fees).
- Annual revenue: sum of the last 30 daily points of totalDataChart x 365/30. Zero days inside the window count, so an adapter gap lowers the run rate instead of hiding it.
- Revenue scope: the DeFiLlama parent the token accrues from (Jupiter, Hyperliquid, GMX, Lighter, ApeX, Derive span several products), so FDV and revenue share one scope.
- FDV source: CoinGecko /coins/markets fully_diluted_valuation (falls back to market_cap if FDV null). dYdX is priced on the dYdX Chain token (CoinGecko dydx-chain).
- P/E = FDV / annual_revenue. Null if FDV or revenue unavailable.
- Protocols whose adapter publishes no revenue series (Aster, Avantis, Orderly) or reports zero (Drift perps) have no P/E; see bench 265 for their price to fees.
- Poll cadence: harness fetches DeFiLlama + CoinGecko every 60 minutes. Prometheus scrapes :2112/metrics every 30 seconds. The sample count per row is the number of scrapes in the 24h window (about 2,880), not a count of trades.

## Dogecoin RPC endpoints: free public URLs by 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: Tatum has the lowest median latency of the 2 free public Dogecoin RPC endpoints measured above the 50 % success floor (3 listed), 104 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 104 ms (p99 292 ms, success 75.2%, sample 4317.87)
2. dRPC: 188 ms (p99 764 ms, success 98.8%, sample 4316.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Dogecoin-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=dogecoin. Provider coverage today: 3 endpoints.

## Zcash RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Zcash RPC endpoints measured, 94 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 94 ms (p99 240 ms, success 75.5%, sample 4319.87)
2. Blockchair: 148 ms (p99 574 ms, success 100.0%, sample 4319.87)
3. Tatum (Zebra): 161 ms (p99 313 ms, success 75.7%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload (Tatum zcashd, Tatum Zebra): {"jsonrpc":"2.0","id":<rotating>,"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Zcash-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=zcash. Provider coverage today: 3 endpoints (Tatum zcashd, Tatum Zebra, Blockchair).

## Robinhood Chain RPC endpoints: free public URLs and private API-key providers by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/robinhood-rpc
- JSON: https://openchainbench.com/api/stat/robinhood-rpc
- Status: live
- Headline: dRPC has the lowest median latency of the 4 free public Robinhood Chain RPC endpoints measured, 27 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 27 ms (p99 137 ms, success 99.0%, sample 4318.87)
2. PublicNode: 71 ms (p99 144 ms, success 100.0%, sample 4318.87)
3. bloXroute: 104 ms (p99 163 ms, success 100.0%, sample 4319.87)
4. Robinhood: 902 ms (p99 2.17 s, success 100.0%, sample 4318.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/robinhood-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/robinhood-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Robinhood Chain RPC endpoints measured, 11 ms (p50, 24h, 3 regions).
1. GetBlock: 11 ms (p99 76 ms, success 100.0%, sample n/a)
2. Chainstack: 33 ms (p99 114 ms, success 100.0%, sample n/a)
3. QuickNode: 33 ms (p99 50 ms, success 100.0%, sample n/a)
4. Alchemy: 36 ms (p99 72 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: the public cohort every 60 seconds per provider from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore), its headline p50/p90/p99 aggregating all 3 via Prometheus `avg(quantile_over_time(...))`. The keyed cohort runs every 120 seconds from us-east and eu-west and aggregates those two. Per-region breakdowns are first-class via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Robinhood Chain-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="robinhood" (chain id 4663). Provider coverage: 4 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.
- Private cohort (Access selector, Private): Chainstack, Alchemy, QuickNode and GetBlock probed on their keyed Robinhood Chain endpoints every 120 seconds from us-east and eu-west, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; Alchemy: the Mobula enterprise-tier key; Alchemy states free and paid keys share one routing; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; GetBlock: a Starter plan, 50M compute units per month shared by the two probe regions, 20 CU per call.
- GetBlock regional pairing: us-east uses GetBlock's New York endpoint and eu-west its Frankfurt endpoint. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- GetBlock coverage: GetBlock does not offer Robinhood Chain in Singapore, so no GetBlock row exists for that region: the endpoint is not offered there, which is not a failed or pending measurement. The whole keyed cohort is therefore measured from us-east and eu-west, because averaging a two-region row against three-region rows would compare different populations.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.
- Robinhood Chain runs on the Arbitrum Orbit stack with about 100 ms block times; the probe samples the serving path, not block production. The stale check tolerates 200 blocks behind the cross-provider tip (20 s of wall clock, the same tolerance as the 1 s chains at 20 blocks) on the public cohort and 20 blocks on the keyed one.

## Bitcoin Cash RPC endpoints: free public URLs by 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) has the lowest median latency of the 3 free public Bitcoin Cash RPC endpoints measured, 97 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Bitcore (Bitpay): 97 ms (p99 166 ms, success 100.0%, sample 4318.87)
2. BiggestFan Node: 111 ms (p99 496 ms, success 99.8%, sample 4316.9)
3. Blockchair: 148 ms (p99 166 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload (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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Bitcoin Cash-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=bitcoin-cash. Provider coverage today: 3 endpoints (Blockchair, Bitcore, BiggestFan).

## Litecoin RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Litecoin RPC endpoints measured above the 50 % success floor (3 listed), 93 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 93 ms (p99 275 ms, success 75.2%, sample 4318.87)
2. LitecoinSpace: 110 ms (p99 5.16 s, success 53.3%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload (Tatum): {"jsonrpc":"2.0","id":<rotating>,"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 measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Litecoin-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=litecoin. Provider coverage today: 3 endpoints.

## Babylon RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Babylon RPC endpoints measured, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 305 ms, success 100.0%, sample 4318.87)
2. Polkachu: 108 ms (p99 206 ms, success 99.9%, sample 4316.87)
3. LavenderFive: 132 ms (p99 235 ms, success 99.6%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET <endpoint>/status. Returns a Tendermint status JSON object; block height is read from result.sync_info.latest_block_height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Babylon-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=babylon. Provider coverage today: 3 endpoints.

## Acala RPC endpoints: free public URLs by 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-2) has the lowest median latency of the 3 free public Acala RPC endpoints measured, 18 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Acala (RPC-2): 18 ms (p99 233 ms, success 100.0%, sample 4319.87)
2. Acala (RPC-0): 98 ms (p99 221 ms, success 100.0%, sample 4318.87)
3. Dwellir: 444 ms (p99 507 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"chain_getHeader","params":[]}. The result contains a number field (hex-encoded block number).
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Acala-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=acala. Provider coverage today: 3 endpoints (Dwellir, Acala RPC-0, Acala RPC-2).

## Interlay RPC endpoints: free public URLs by 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 is the only free public Interlay RPC endpoint measured, at 125 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Interlay: 125 ms (p99 385 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<rotating>,"method":"chain_getHeader","params":[]}. The result contains a number field (hex-encoded block number).
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Interlay-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=interlay. Provider coverage today: 1 endpoint (Interlay official api.interlay.io/parachain).

## Chihuahua RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Chihuahua RPC endpoints measured, 90 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Validatus: 90 ms (p99 99 ms, success 100.0%, sample 4319.87)
2. Chihuahua: 126 ms (p99 237 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Chihuahua-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=chihuahua. Provider coverage today: 2 endpoints (Chihuahua official, Polkachu, Validatus).

## Sentinel DVPN RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Sentinel DVPN RPC endpoints measured, 74 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 74 ms (p99 250 ms, success 100.0%, sample 4318.87)
2. Polkachu: 124 ms (p99 234 ms, success 75.9%, sample 4317.87)
3. Cosmos Directory: 157 ms (p99 291 ms, success 100.0%, sample 4320.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Sentinel DVPN-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=sentinel. Provider coverage today: 3 endpoints.

## Fetch.ai RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Fetch.ai RPC endpoints measured, 78 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 78 ms (p99 272 ms, success 100.0%, sample 4320.87)
2. Fetch.ai: 153 ms (p99 193 ms, success 100.0%, sample 4318.87)
3. Cosmos Directory: 169 ms (p99 398 ms, success 99.9%, sample 4312.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Fetch.ai-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=fetchhub. Provider coverage today: 3 endpoints (Fetch.ai official, PublicNode, Cosmos Directory).

## Union RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Union RPC endpoints measured, 96 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Nodes.Guru: 96 ms (p99 111 ms, success 100.0%, sample 4318.87)
2. Stake And Relax: 112 ms (p99 374 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Union-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=union. Provider coverage today: 2 endpoints.

## Shentu RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Shentu RPC endpoints measured, 123 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 123 ms (p99 231 ms, success 100.0%, sample 4319.87)
2. High Stakes: 161 ms (p99 671 ms, success 100.0%, sample 4319.87)
3. Shentu: 408 ms (p99 614 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Shentu-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=shentu. Provider coverage today: 3 endpoints (Shentu official, Polkachu, High Stakes).

## MANTRA RPC endpoints: free public URLs by 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: ITRocket has the lowest median latency of the 3 free public MANTRA RPC endpoints measured, 83 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. ITRocket: 83 ms (p99 123 ms, success 66.6%, sample 4317.87)
2. Polkachu: 111 ms (p99 214 ms, success 100.0%, sample 4318.87)
3. MANTRA: 137 ms (p99 286 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field (string-encoded integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the MANTRA-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=mantrachain. Provider coverage today: 3 endpoints (MANTRA official, ITRocket, Polkachu).

## Band Protocol RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public Band Protocol RPC endpoints measured, 114 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Band Protocol: 114 ms (p99 237 ms, success 100.0%, sample 4318.87)
2. High Stakes: 176 ms (p99 689 ms, success 100.0%, sample 4319.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Band Protocol-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=bandchain. Provider coverage today: 2 endpoints (Band Protocol official, High Stakes, Stakewolle).

## cheqd RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public cheqd RPC endpoints measured, 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 79 ms (p99 268 ms, success 100.0%, sample 4318.87)
2. NodeStake: 88 ms (p99 1.01 s, success 80.8%, sample 4314.92)
3. cheqd: 123 ms (p99 516 ms, success 100.0%, sample 4318.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: GET /status. The result.sync_info.latest_block_height field is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the cheqd-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=cheqd. Provider coverage today: 3 endpoints (cheqd official, PublicNode, NodeStake).

## ICON RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public ICON RPC endpoints measured, 44 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. ICON Foundation: 44 ms (p99 71 ms, success 100.0%, sample 4318.87)
2. ICON Community: 136 ms (p99 511 ms, success 100.0%, sample 4318.87)
3. iconblockchain.xyz: 148 ms (p99 402 ms, success 100.0%, sample 4317.87)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: POST /api/v3 with method icx_getLastBlock. The result.height field (decimal integer) is extracted as the current block height.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the ICON-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain=icon. Provider coverage today: 3 endpoints.

## Bitcoin RPC endpoints: free public URLs by 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 has the lowest median latency of the 3 free public Bitcoin RPC endpoints measured, 71 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 71 ms (p99 224 ms, success 100.0%, sample 4319.87)
2. dRPC: 126 ms (p99 233 ms, success 98.8%, sample 4318.87)
3. NOWNodes: 265 ms (p99 408 ms, success 100.0%, sample 4319.87)

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

## LUKSO RPC endpoints: free public URLs by 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 has the lowest median latency of the 2 free public LUKSO RPC endpoints measured, 169 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. LUKSO Foundation: 169 ms (p99 674 ms, success 92.9%, sample 4317.87)
2. NOWNodes: 283 ms (p99 434 ms, success 100.0%, sample 4318.87)

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

## Fastest on-chain bridge execution: real settlement latency, Mobula vs Relay vs LI.FI vs Near Intents

- Category: Bridges
- Metric: Execution latency (ms)
- Page: https://openchainbench.com/benchmarks/bridge-execution-latency
- JSON: https://openchainbench.com/api/stat/bridge-execution-latency
- Status: live
- Headline: Mobula posts the lowest execution latency at 1.01 s (p50, 7d) across 4 ranked providers.

**Rankings (p50, 7d):**
1. Mobula: 1.01 s (p99 1.12 s, success 100.0%, sample 21)
2. Relay: 1.90 s (p99 2.03 s, success 100.0%, sample 24)
3. LI.FI: 3.64 s (p99 3.98 s, success 100.0%, sample 24)
4. Near Intents: 1.0 min (p99 1.3 min, success 100.0%, sample 18)

**Methodology**:
- Route: a self-conserving all-USDC triangle. Solana USDC to Base USDC, Base USDC to Arbitrum USDC, Arbitrum USDC to Solana USDC. Each executing bridge completes the full triangle before the next starts, so inventory returns to its origin and only fees burn.
- Ticket sizes: $3 daily and $30 twice weekly (Monday and Thursday), on fixed UTC schedules, pooled in every figure and labelled amount_usd in Prometheus. Amounts are deliberately small: this measures settlement reliability, not large-ticket cost. Window: 7 days, so each bridge and corridor carries about 7 to 9 executions; a 24-hour window would hold one.
- Latency: measured by the harness at both ends on one clock, every 100 ms on keyed RPCs. The recipient's balance is watched from before the deposit is broadcast (first read above the pre-execution balance = credit observed); the deposit's inclusion is watched from the broadcast (receipt on Base and Arbitrum, signature status on Solana = source included). Published figure = credit observed minus source included, in milliseconds.
- Latency precision: detection lag is at most 100 ms plus one RPC round-trip on each end. The destination block timestamp minus the source block timestamp is published alongside as bridge_exec_onchain_ms as a whole-second cross-check (the two chains' clocks can disagree by a block).
- Latency history: until 2026-09-19 the figure was the wall clock to a 5-second status poll, which floored every fill at 5.x s; that series stays as bridge_exec_observed_ms and the poll-era history was deleted from Prometheus.
- Latency fallbacks: a settled execution the watch missed falls back to credit minus broadcast, then to the block delta, then to the wall clock. Every published value carries a method label (watch, watch-broadcast, blocks, poll) and bridge_execution_latency_fallback_total counts the non-watch ones by method.
- Outcome classification: settled (funds received), reverted or refunded (capital returned to source), or errored (never broadcast). Only settled transactions contribute to the latency distribution; reverts, refunds and stuck deposits count against the success rate.
- Region: EU-West only at present. The execution node runs a single wallet, so a second origin would race the same inventory; additional origins are not planned for the execution loop.
- Cohort: Mobula, Relay, LI.FI and Near Intents (Near Intents runs its own conserving USDC triangle via the 1Click flow). deBridge is quote-only in this loop. Providers without a symmetric route on all three legs are excluded so the triangle conserves.
- Cost metrics captured per real execution (beyond latency and success): realized output on-chain, execution slippage vs the quote (realized fee minus quote-projected fee), our own on-chain gas paid (approve + deposit, measured as source-chain native balance delta), and the refund rate split from hard-fail rate. These surface the true all-in cost and the gap between a quote and what actually settles.
- Reliability tail: cross-chain settlement is asynchronous, so a broadcast can end three ways beyond a clean fill. We split them: refunded (capital returned, with a refund-latency histogram for how fast it came back), reverted (on-chain failure), and stuck (a deposit whose status never resolved to a fill or refund in the poll window). The stuck rate is the share of swaps a user would have to chase manually: the honest measure of what is not automatically handled.

## Bridge slippage vs quote: what actually settles versus what was quoted

- Category: Bridges
- Metric: Slippage vs quote (usd)
- Page: https://openchainbench.com/benchmarks/bridge-realized-cost
- JSON: https://openchainbench.com/api/stat/bridge-realized-cost
- Status: live
- Headline: LI.FI posts the lowest slippage vs quote at -$0.00566 (7d) across 4 ranked providers.

**Rankings (p50, 7d):**
1. LI.FI: -$0.00566 (p99 -$0.00564, success 100.0%, sample 24)
2. Mobula: -$0.00253 (p99 -$0.00244, success 100.0%, sample 21)
3. Relay: $0.0000023 (p99 $0.0000035, success 100.0%, sample 24)
4. Near Intents: $0.00780 (p99 $0.00785, success 100.0%, sample 18)

**Methodology**:
- Route: a self-conserving all-USDC triangle (Solana to Base, Base to Arbitrum, Arbitrum to Solana). Each bridge completes the full triangle before the next starts, so inventory returns to origin and only fees burn.
- Slippage vs quote: realized fee minus quoted fee, in USD (bridge_quote_slippage_usd). Realized fee is the ticket minus what actually landed on the destination, read from the balance delta; quoted fee is the ticket minus the output the quote promised, one definition for every bridge. Near zero means the settlement matched the quote; positive means it settled worse; negative means it beat the quote.
- Why not the providers' own fee fields: some mix in gas paid in the native token, which the realized fee (ticket minus landed) can never contain, so one bridge read a constant negative offset at every ticket size. Both sides of the subtraction are now defined against the ticket.
- All-in gas: our own on-chain gas to execute (approve plus deposit), measured as the source-chain native balance delta before and after (bridge_exec_gas_usd). This is the cost the user bears on top of the bridge fee.
- Realized fee: ticket minus the value that landed on the destination chain, in basis points of the ticket (bridge_exec_realized_fee_bps), so $3 and $30 executions compare. Published only for settled executions whose destination balance was read on-chain; a leg whose credit was not visible within 30 s publishes nothing and is counted in bridge_realized_fallback_total.
- Ticket sizes: $3 daily and $30 on Monday and Thursday, pooled. Small on purpose, since this measures the quote-to-settlement gap, not large-ticket depth. Window: 7 days, about 7 to 9 executions per bridge and corridor.
- Region: EU-West only. The execution node runs a single wallet, so a second origin would race the same inventory.
- Cohort: Mobula, Relay, LI.FI and Near Intents, the bridges executed on all three legs. Quote-only providers are covered by the bridge-fee and bridge-quote-latency benchmarks.

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

- Category: Bridges
- Metric: Quote latency (ms)
- Page: https://openchainbench.com/benchmarks/bridge-quote-latency-solana
- JSON: https://openchainbench.com/api/stat/bridge-quote-latency-solana
- Status: live
- Headline: Mobula posts the lowest quote latency at 57 ms (p50, 24h) across 6 ranked providers.

**Rankings (p50, 24h):**
1. Mobula: 57 ms (p99 908 ms, success 52.6%, sample 1519)
2. deBridge: 112 ms (p99 2.16 s, success 100.0%, sample 2878)
3. Relay: 250 ms (p99 496 ms, success 99.1%, sample 2852)
4. Across: 276 ms (p99 499 ms, success 100.0%, sample 1152)
5. LI.FI: 736 ms (p99 2.97 s, success 68.3%, sample 1965)
6. Near Intents: 3.50 s (p99 4.97 s, success 99.5%, sample 1146)

**Methodology**:
- Origin: Solana only. Every corridor in this bench starts from Solana USDC; the destination is the per-tab chain.
- Destinations: Base, Arbitrum, BNB, Ethereum and Robinhood Chain. A provider that does not quote a given destination simply does not appear on that tab.
- Robinhood Chain (Arbitrum Orbit, chainId 4663) has no native USDC, so it is a cross-asset USDC to USDG (Global Dollar) corridor. Mobula, Relay, LI.FI and deBridge all quote it today (the pair was rejected by three of them at launch); Across and Near Intents are not attempted on this destination.
- Latency: wall-clock from request to a fully read quote response, in milliseconds. p50, p90 and p99 over a rolling 24h window via histogram_quantile on a from_chain=Solana-scoped recording rule, summed over the destinations and notionals of the tab (the All tab pools every destination). Near Intents' dry quotes carry a fixed 3 s solver wait (quoteWaitingTimeMs: 3000), so its figures sit at about 3 s by construction; the histogram has 500 ms buckets between 1 and 5 s to resolve it.
- Cadence: every five minutes, at $5, $50 and $300 notional.
- Region: every figure on this page is pinned to the EU-West (Paris) origin. A us-east probe also runs and its cells are kept in Prometheus, but they are not pooled into the headline; the sgp probe is down.
- Cohort: Mobula, Relay, LI.FI, deBridge, Across and Near Intents. Squid and Socket are EVM-only aggregators with no Solana-source route and are excluded here (they remain in the general bridge-quote-latency bench). Across and Near Intents are probed on Base and Arbitrum only: the harness maps no BNB, Ethereum or Robinhood asset for them yet, so their absence from those tabs is ours, not theirs. The R4 meme route (TRUMP to BRETT) quoted by the same loop is excluded from every cell.

## Perp DEX price to fees: what the market pays per dollar of trading fees

- Category: Trading
- Metric: P/F ratio (x)
- Page: https://openchainbench.com/benchmarks/perp-pf-ratio
- JSON: https://openchainbench.com/api/stat/perp-pf-ratio
- Status: live
- Headline: GNS posts the lowest P/F ratio at 0.993x (24h) across 13 ranked protocols.

**Rankings (P/F, 24h):**
1. GNS: P/F 0.993x (success 100.0%, sample 2880)
2. GMX: P/F 1.416x (success 100.0%, sample 2880)
3. EDGE: P/F 3.38x (success 100.0%, sample 2880)
4. JUP: P/F 5.29x (success 100.0%, sample 2880)
5. F (SynFutures): P/F 6.22x (success 100.0%, sample 2880)
6. APEX: P/F 8.09x (success 100.0%, sample 2880)
7. ORDER: P/F 8.80x (success 100.0%, sample 2880)
8. AVNT: P/F 11.2x (success 100.0%, sample 2880)
9. LIT: P/F 15.7x (success 100.0%, sample 2880)
10. HYPE: P/F 19.3x (success 100.0%, sample 2880)
11. ASTER: P/F 30.6x (success 100.0%, sample 2880)
12. DYDX: P/F 37.5x (success 100.0%, sample 2880)
13. DRV: P/F 48.4x (success 100.0%, sample 2880)

**Methodology**:
- Fees source: DeFiLlama dailyFees for the token's parent entity (all products the token accrues from), so market cap and fees share one scope. Perps-only fees are published separately as perp_protocol_perp_fees_30d_usd.
- Annualized fees: sum of the last 30 daily points x 365/30. Zero days inside the window count; the current partial day is included, as in DeFiLlama's own 30d figure.
- Market cap and FDV: CoinGecko /coins/markets circulating market cap and fully_diluted_valuation (market cap when FDV is null). Float = circulating / total supply.
- P/F = market cap / annualized fees (DeFiLlama P/F convention). FDV/F = FDV / annualized fees. P/S = market cap / annualized protocol revenue (DeFiLlama dailyRevenue). Bench 234 keeps P/E = FDV / annualized revenue.
- Revenue share = 30d revenue / 30d fees. Adapters that publish no revenue series, or a flat zero, leave P/S and revenue share undefined rather than zero.
- Open interest: DeFiLlama open-interest overview, perps product only. Fees to OI = annualized fees / open interest.
- Drift's DeFiLlama perps adapter (drift-trade) currently reports zero fees; the row stays in the cohort with every ratio undefined until the source recovers.
- Pre-TGE venues (Ostium, Pacifica, Extended, Nado, Decibel) are declared `unranked` in the spec: they sit under the ranked field with their fees and open interest, are excluded from ranks, leader claims and the best / median / worst strip, and gain a ratio the day a token lists.
- edgeX (EDGE) has a listed token and is ranked. Paradex (DIME) has one too, but DeFiLlama's fee adapter reports very low fees for it, which inflates its multiple; it is declared `unranked` (shown below the field with its figures) until the adapter is fixed upstream, so a known artifact never reads as the highest multiple in the cohort.
- Poll cadence: DeFiLlama and CoinGecko every 60 minutes. Prometheus scrapes :2112/metrics every 30 seconds. The sample count per row is the number of scrapes in the 24h window (about 2,880), not a count of trades; p50, p90 and p99 read the same instant gauge, so they are equal by construction.

## Perp DEX daily volume 2026: Hyperliquid, Aster, Lighter, GMX, Gains, dYdX by UTC day, backfilled

- Category: Trading
- Metric: Daily perp volume (usd)
- Page: https://openchainbench.com/benchmarks/perp-daily-volume
- JSON: https://openchainbench.com/api/stat/perp-daily-volume
- Status: live
- Headline: Hyperliquid leads daily perp volume at $5.75B (24h) across 11 ranked venues.

**Rankings (Volume, 24h):**
1. Hyperliquid: Volume $5.75B (success 100.0%, sample 362)
2. Lighter: Volume $2.06B (success 100.0%, sample 422)
3. Hyperliquid HIP-3: Volume $2.06B (success 100.0%, sample 324)
4. Aster: Volume $1.72B (success 100.0%, sample 422)
5. Extended: Volume $273.48M (success 100.0%, sample 422)
6. Orderly: Volume $45.30M (success 100.0%, sample 422)
7. GMX V2: Volume $34.04M (success 100.0%, sample 422)
8. dYdX v4: Volume $32.17M (success 100.0%, sample 422)
9. Gains: Volume $17.75M (success 100.0%, sample 422)
10. Paradex: Volume $14.73M (success 100.0%, sample 422)
11. Aevo: Volume $1.83M (success 100.0%, sample 422)

**Methodology**:
- Day bucket: UTC midnight to midnight, the DeFiLlama convention. The headline is the last fully closed UTC day (D-1); the current day is never shown.
- One side per trade: every source counts taker notional once. Extended reports both sides per market, halved here as in the DeFiLlama adapter.
- GMX V2: gmx.squids.live volumeInfos period 1d, marginVolumeUsd scaled by 1e-30, summed over Arbitrum, Avalanche, Botanix and MegaETH. Swap volume is excluded, so this is the GMX V2 Perps line, not the GMX parent.
- Gains: the published series is the Dune view dune.gains.result_g_trade_stats_defi_llama, the source DeFiLlama's own adapter reads (Arbitrum, Polygon, Base, MegaETH; ApeChain is not in the view), queried at most every 12 hours.
- Gains between two Dune runs: the newest day comes from backend-global.gains.trade /api/volume-mix, autoVolumeUsd + directVolumeUsd (opens and closes at full notional, resizes at the traded delta, governance-only rows excluded). It matched the view within 0.1 percent over the 60 days checked; the gap between the two is published as a divergence gauge.
- Hyperliquid: info candleSnapshot 1h per market; hourly notional = base volume x (open + high + low + close) / 4, summed per day. Checked against the exchange's own dayNtlVlm at UTC midnight on 2026-09-13: 3.361B from candles vs 3.359B native.
- Hyperliquid rows: the main dex is the Hyperliquid row; the HIP-3 dexs listed by perpDexs (xyz, io, mkts, para, km, flx...) are builder-deployed markets and get their own row, Hyperliquid HIP-3. DeFiLlama's single hyperliquid-perps figure sits between the two because its private indexer covers HIP-3 only partially.
- Aster: fapi.asterdex.com 1d klines quoteVolume summed over TRADING perpetual symbols. Lighter: 1d candles quote volume summed over perp markets (market_id below 2048) on zkLighter mainnet and on the Robinhood chain deployment (api.rh.lighter.xyz), the two DeFiLlama's Lighter parent adds. dYdX v4: indexer 1DAY candles usdVolume summed over all perpetual markets.
- Paradex: the public Metabase daily card, PERP_VOLUME column (options and spot excluded). Extended: exchange/stats/trading per day on Starknet, plus the Ethereum deployment until 2025-12-29. Orderly: md/volume/daily_stats. Aevo: statistics with instrument_type PERPETUAL per day.
- Windows: 7d and 30d are sums of closed days ending on D-1 and are published only when every day in the window is present, so a partial backfill never reads as a low week. Share is the venue's window total over the sum of the cohort on the same window.
- Refresh: full backfill on first boot (400 days, bounded by each source's start date; Hyperliquid candles reach back about 340 days), then every hour every venue re-reads its last three closed days in parallel so restated days converge. A venue whose source rate-limits (dYdX's indexer) or whose host is down (Extended's retired Ethereum deployment) is skipped for that sweep and keeps its stored days. Prometheus scrapes :2112/metrics every 60s.
- Not covered yet: edgeX, GRVT, Pacifica, Vertex, Backpack, Jupiter, Drift and Ostium. The first three follow the same per-market candle pattern and are next; Drift and Ostium exist on DeFiLlama only through Dune queries.

## Trading app daily volume 2026: GMGN, Axiom, FOMO, Terminal, Photon, Trojan by UTC day, every chain

- Category: Trading
- Metric: Daily volume (usd)
- Page: https://openchainbench.com/benchmarks/trading-app-daily-volume
- JSON: https://openchainbench.com/api/stat/trading-app-daily-volume
- Status: live
- Headline: FOMO leads daily volume at $133.89M (24h) across 14 ranked providers.

**Rankings (Volume, 24h):**
1. FOMO: Volume $133.89M (success 100.0%, sample 131)
2. Axiom: Volume $131.99M (success 100.0%, sample 129)
3. GMGN: Volume $98.20M (success 100.0%, sample 1088)
4. pump.fun app: Volume $21.03M (success 100.0%, sample 137)
5. Terminal: Volume $17.58M (success 100.0%, sample 126)
6. Trojan: Volume $3.91M (success 100.0%, sample 126)
7. Banana Gun: Volume $3.27M (success 100.0%, sample 120)
8. SolTradingBot: Volume $1.33M (success 100.0%, sample 126)
9. Photon: Volume $1.32M (success 100.0%, sample 153)
10. Bloom: Volume $1.31M (success 100.0%, sample 125)
11. BullX: Volume $1.19M (success 100.0%, sample 124)
12. BONKbot: Volume $676.0K (success 100.0%, sample 125)
13. o1.exchange: Volume $183.2K (success 100.0%, sample 360)
14. Pepeboost: Volume $81.1K (success 100.0%, sample 53)

**Methodology**:
- Source: DeFiLlama dexs summary, free endpoint, categories Trading App and Telegram Bot, plus pump.fun's mobile app. One request per app per hour.
- Scope: every chain the app's DeFiLlama adapter covers, summed. The per-chain split of the last closed day is published as trading_app_volume_chain_usd{app,chain}.
- Day bucket: UTC, closed days only; the open day is never published. DeFiLlama can restate the last closed day for about 24 hours; the full series is re-read every hour so restatements land.
- Anchor: each app's latest closed day on DeFiLlama (trading_app_last_day_unix). Most adapters are Dune queries that refuse to run until 10 hours after the day closes, so a day typically lands between 10:00 and 20:00 UTC the next day; GMGN's adapter also skips some days. Before that, the app's row shows the previous day, dated, rather than nothing.
- Windows: 1d = the app's latest closed day (headline). 7d and 30d are sums over the 7 / 30 closed days ending on it, published from 80 percent day coverage; the number of days behind a sum is shown next to it.
- Share: app volume over the cohort total on the same window, in percent.
- History: up to 400 closed days per app (adapter start dates differ: GMGN from 2023, FOMO and Axiom from May 2026).
- Health: 1 when the app's latest closed day is within 3 days of yesterday UTC.
- Not covered: apps without a DeFiLlama dexs adapter (Maestro publishes fees only, BasedBot has none). They stay on the Dune-based bench 208 where they have data.

## Trading terminal fill quality 2026: what a swap costs on Axiom, GMGN, FOMO, Photon, Trojan, measured on-chain

- Category: Trading
- Metric: Cost per swap (bp)
- Page: https://openchainbench.com/benchmarks/terminal-fill-quality
- JSON: https://openchainbench.com/api/stat/terminal-fill-quality
- Status: live
- Headline: pump.fun app posts the lowest cost per swap at 229 bps (p50, 24h) across 10 ranked providers.

**Rankings (Value lost, 24h):**
1. pump.fun app: Value lost 229 bps (success 100.0%, sample 285)
2. FOMO: Value lost 329 bps (success 100.0%, sample 590)
3. GMGN: Value lost 334 bps (success 100.0%, sample 466)
4. BONKbot: Value lost 360 bps (success 100.0%, sample 134)
5. Terminal: Value lost 376 bps (success 100.0%, sample 136)
6. Trojan: Value lost 389 bps (success 100.0%, sample 112)
7. Axiom: Value lost 413 bps (success 100.0%, sample 249)
8. Pepeboost: Value lost 434 bps (success 100.0%, sample 130)
9. Maestro: Value lost 447 bps (success 100.0%, sample 417)
10. Bloom: Value lost 479 bps (success 100.0%, sample 261)

**Methodology**:
- Trade-size views: the same window split at $25 and $250 of trade value. Each bucket's figures are plain medians over its own swaps, where the All-sizes row weights each chain's median by its flow; inside one size bucket of one product there is no chain mix to correct for. Failed swaps and failure overhead stay blank under a size filter: a failed attempt never reached a pool and has no trade size. A bucket needs 20 priced swaps to publish and 40 to be ranked, so thin buckets read as provisional.
- Sampling: a WebSocket feed of every transaction mentioning each terminal's fee wallets (DeFiLlama adapters, Dune's spellbook: Axiom 22, GMGN 9, Trojan 6, Terminal 2, the others 1; pump.fun's app and Banana Gun also by program). The logs say whether a swap program was invoked: only those count as attempts, all of them for the fail rate; 150 successful ones per row per day are read (Solana and EVM alike), drawn at random, weighted by the tick's activity (clamped). Rolling 24 h.
- The user is the signer whose token balance moved; when nobody signed for the user (limit, DCA and auto-sell orders executed by the terminal's keeper), the wallet whose token account moved against its SOL / stable balance, never a program-derived pool address. Quote assets: SOL, USDC, USDT, USD1, USDS, PYUSD; token-to-token swaps are not measured.
- Quote side, exact from balance deltas: user_q = what left or reached the user's SOL / WSOL / stable balance, the tx fee and the deposit of new token accounts (~0.002 SOL each, network cost; a refund on close is not credited) included; pool_q = the pool's quote movement, in the user's quote unit; terminal_q = lamports, WSOL or stables landing in the fee wallets (FOMO: plus its user-signed USDC legs).
- network_q = tx fee if the user paid it + inclusion tips: Jito, 0slot, bloXroute, Astralane, Nozomi and each terminal's own relay accounts (Axiom, Trojan, Maestro, Photon, Pepeboost, pump.fun app). other_q = user_q minus pool_q, terminal_q and network_q on single-pool routes without hops (pump.fun protocol and creator fees, referral payouts); on routed swaps it stays inside pool.
- Pool identity: the token vault that moved against the user and the quote vault of the same swap instruction, both by pubkey. Two pools behind one shared authority (Raydium, Launchpad, Meteora DAMM v2) never merge, so a hop through a sibling pool is never read as pool impact and the previous-trade lookup only sees that pool.
- Reference price, in order: the pool's exact pre-trade mid from its balances in the transaction (PumpSwap, Raydium); the venue's swap event when it carries the pre-trade state (Launchpad, DLMM) and reconciles with the vault deltas; else the previous trade on the pool, at most 60 s old (pump.fun curve, CLMM, routed swaps), up to 2 h on the EVM launchpad curves BasedBot's router trades on. No off-chain token price; gas coins at Coinbase spot on Relay rows, at the route's hop mid on native EVM rows.
- Loss (headline): buy = 1 − tokens × ref / user_q; sell = 1 − user_q / (tokens × ref). Basis points of the trade (buy: quote spent; sell: tokens × ref; either plus the gas when the user paid it outside the quote asset). Pool = loss minus terminal, network and other: the components (relay on Relay rows) sum to the loss per swap; the split columns are medians (flow-weighted on All chains) and do not sum to the median loss. Losses outside −10 % to +50 % stay out. Median with its 95 % interval, p90.
- A product is published from 50 priced swaps in the window (a chain row, or a single-chain product, from 25) and marked as ranked from 100; a pooled entry also needs 25 effective swaps (weights considered), a row with one side only and no fee on it waits, and a product waits while its main chain fills. The previous-trade reference carries the previous trader's direction, so terminals priced mostly that way read some tens of bps worse in buy waves than on the exact mid.
- Fail rate: failed over every swap attempt the feed saw on the terminal's wallets in the window, exhaustive; wallet funding, fee sweeps and marker transfers invoke no swap program and are not attempts. Error classes are in the JSON. On the EVM rows the fail rate comes from a sample of blocks read in full (every transaction sent to the routers, reverted or not).
- Cost of failures: 40 failed attempts per terminal per day are read for the fee they paid (a failed transaction executes nothing but pays base + priority fee; zero when the terminal sponsors gas). Failure overhead = fail rate / (1 − fail rate) × median failed fee, in bps of the median trade: what a successful swap carries on average in wasted attempts. Published apart from the cost per swap, not added to it.
- PumpSwap's vault ratio alone is not the mid: pools migrated from pump.fun add a virtual quote reserve (about 17.6 SOL) that the pool account stores; with it x·y = k matches executed trades exactly. pump.fun's 2026 bonding curve fills 20 to 60 % above its stored virtual_sol / virtual_token, so the curve gets the previous-trade reference instead.
- Sandwiches: each sampled swap's neighbours on its pool are screened (another signer trading our direction in our slot just before, and back just after, closing a comparable position with a take). Kept per swap in the JSON with the attacker and both signatures, not published as a column: how many swaps can be screened depends on pool activity, so terminals are not comparable on it.
- Trade-size buckets (under $25, $25 to $250, over $250): median loss per bucket in the public JSON and on each product page, so terminals with different typical trade sizes are compared at equal size.
- One row per product; the chain selector shows the product on one chain (Solana and five EVM chains), All chains pools its swaps across chains (bridge funding legs stay out). Each chain is sampled at a fixed daily rate, so All chains weighs a chain's sampled swaps by its swap attempts per sample: the pooled figure follows the users, not the sampler. Published from 50 priced swaps pooled over the chains at 25 or more; it waits while the chain carrying most of the flow fills.
- Cross-chain (FOMO): the user pays on BNB, Robinhood Chain, Base, Ethereum or Arc and Relay delivers on Solana. Relay's public requests feed identifies the app's requests (fee address or referrer) with what the user sent in USD, the fees, both hashes and the status. Value received = what the settlement delivered on Solana: USDC / SOL exactly (FOMO funds the wallet this way; the token buy that follows is a native swap in the FOMO row) or a token at the pool's state before the swap.
- Cross-chain split: terminal = the app fee the user paid; network = origin gas plus the destination gas Relay charged (its fee breakdown); relay = Relay's fixed and price fees plus the solver's spread (deposit minus received minus app fee minus that gas); pool only when a token was delivered. A token sold on the origin chain is priced at that chain's pool state in its per-chain row. Refunds and failures count in the fail rate. Perps are not measured; swaps under $2 are dropped.
- Trading on another chain (FOMO on Robinhood Chain, BNB, Base, Ethereum, Arc): the user pays in USDC or SOL from the FOMO wallet, a Relay solver buys the token there. Value given = what was sent (tx fee inside); value received = the tokens delivered at the pool's state before the settlement swap: v2 forks from the Sync reserves minus the swap, v3 forks and Uniswap v4 from the price left by the previous swap on the pool, all from the pool's own logs on public RPCs.
- Which side of an EVM pool is the token is settled by matching the swap event's amounts with the receipt's transfers, not the pool's token order. Split: terminal = the app fee; relay = what Relay kept (fees, spread, gas); pool = the settlement swap's impact and LP fee; network = the Solana tx fee (0 when the app's sponsor signs). Sales the other way (a token sold on that chain, USDC or SOL delivered on Solana) sit in the same per-chain row, priced at the origin pool's state before the sale.
- FOMO sponsors gas: its own signer pays the tx fee out of the fee the user paid, so it reads as network cost and comes off the terminal fee; its fee is a router commission plus user-signed USDC legs, all counted as terminal fee. pump.fun's app takes no fee; the fixed 0.001 SOL it forwards on some swaps is counted as network.
- Native EVM (GMGN and Axiom on BNB and Robinhood Chain, Banana Gun): their router contracts emit an event on every swap; eth_getLogs on those routers lists every successful swap they routed; the fail rate comes from a sample of blocks read in full (every tx sent to the routers, reverted or not). Value given = what the user sent plus gas; received = the tokens at the pool's state before the swap; the fee is paid inside the router as a native transfer: the residual after pool and gas.
- Unpriced draws: on the EVM rows a share of the drawn swaps (about a sixth on BNB; on Robinhood Chain 2 of 35 fills on 2026-09-21 once the launchpad curves and ETH-quoted v4 pools were decoded) cannot be valued at the pool's state and stays out of the figure; a token launch's first curve buy is its own reject (launch_first_trade), not a fill; each entry's unpriced_share and its rejects in the JSON say how much and why.
- Cohort discovery: the fee wallets and routers are learned from the chain, the lists being the seed. On a platform's transactions (Mobula's attribution as the sample, every 6 h), a recipient taking a fixed share of the trade across many payers is its fee wallet, adopted from 30 swaps of 20 payers with a stable 20 to 300 bps share; on EVM the transactions' destination is its router. The window's swaps also give the fee-like recipients no terminal lists yet (JSON, 'discovery').
- Phantom (Solana): its in-wallet swap pays 0.85 % to its fee wallet in SOL or WSOL, sampled like the other Solana terminals. Binance Wallet (BSC, Ethereum, Base): one router on the three chains, no event of its own, so its swaps are the transactions sent to it in blocks read in full; valued like the other native EVM rows. Terminal's EVM fee wallets get under $10 a day: not measured. Banana Gun on Ethereum: buys only, no fee, its users sell on Uniswap directly; held out (one side).
- four.meme's bonding curve on BNB is priced exactly: the curve is a constant product on virtual reserves (checked on consecutive trades to 1e-12), its constants come from the TokenManager's token info, so the mid before the trade is known; the launchpad's 1 % fee is 'other', like pump.fun's on Solana.
- Kept out of that residual: a fee the pool's own hook keeps (v4 launchpad pools on Robinhood Chain 1 %, BNB 3.8 %, paid whatever the router) is a pool cost; a native leg (BNB sent, ETH received) is valued at the mid of the route's own stable-to-gas-coin hop before that hop, so the hop's LP fee and impact stay a pool cost; Axiom's inclusion tip (0.0025 BNB fixed; on Robinhood Chain the user's setting, from the call trace) is network cost, like the Solana tip relays.
- Not in the table: BullX (suspended June 2026), Nova (no live fee wallet), Bloom on Base and Ethereum (a swap an hour), Photon on EVM. BasedBot's Relay requests are its in-app bridge between the user's Solana and EVM wallets, both ways, no app fee (a bridge leg, not a trade); its EVM rows are those wallets' swaps on its router. On Solana its fee is a separate transaction after the swap, so failed swaps are not seen: no fail rate there.

## Arc RPC endpoints: free public URLs and private API-key providers by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/arc-rpc
- JSON: https://openchainbench.com/api/stat/arc-rpc
- Status: live
- Headline: dRPC has the lowest median latency of the 6 free public Arc RPC endpoints measured, 31 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 31 ms (p99 112 ms, success 99.5%, sample 4318.87)
2. Arc: 46 ms (p99 170 ms, success 100.0%, sample 4319.87)
3. QuickNode (Arc endpoint): 48 ms (p99 310 ms, success 100.0%, sample 4317.87)
4. PublicNode: 72 ms (p99 199 ms, success 100.0%, sample 4319.87)
5. Blockdaemon: 82 ms (p99 260 ms, success 100.0%, sample 4318.87)
6. Tenderly Gateway: 107 ms (p99 125 ms, success 97.6%, sample 4316.87)

**Private, API key cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/arc-rpc#tier=keyed
- JSON: https://openchainbench.com/api/stat/arc-rpc?tier=keyed
- Headline: GetBlock has the lowest median latency of the 4 private (API-key) Arc RPC endpoints measured, 14 ms (p50, 24h, 3 regions).
1. GetBlock: 14 ms (p99 84 ms, success 100.0%, sample n/a)
2. QuickNode: 33 ms (p99 48 ms, success 100.0%, sample n/a)
3. Alchemy: 45 ms (p99 114 ms, success 100.0%, sample n/a)
4. Chainstack: 53 ms (p99 217 ms, success 100.0%, sample n/a)

**Methodology**:
- Cadence: the public cohort every 60 seconds per provider from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore), its headline p50/p90/p99 aggregating all 3 via Prometheus `avg(quantile_over_time(...))`. The keyed cohort runs every 120 seconds from us-east and eu-west and aggregates those two. Per-region breakdowns are first-class via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. Non-cacheable by design: the latest-header fetch with a rotating id defeats edge caches that answer eth_blockNumber without touching a node.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the archive-depth audit follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Arc-scoped view of the same harness, with the same exclusion rules.
- Chain scope: every query on this page is pinned to chain="arc" (chain id 5042). Provider coverage: 6 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. Exclusions follow the cluster-wide rules documented on the parent benchmark.
- Endpoints published by the chain: the RPC endpoints page of the Arc docs lists Circle's primary endpoint plus Alchemy, Blockdaemon, dRPC and QuickNode. The Blockdaemon and QuickNode rows are Arc-branded URLs (rpc.blockdaemon.mainnet.arc.io, rpc.quicknode.mainnet.arc.io) that answer without a key, verified before inclusion, and are measured here as such.
- The dRPC row of that table (rpc.drpc.mainnet.arc.io) serves the same free tier as arc.drpc.org, identical x-drpc-owner-id, and is measured once under dRPC; the Alchemy row needs a key and sits in the private cohort.
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock and QuickNode probed on their keyed Arc endpoints every 120 seconds from us-east and eu-west, same call (eth_getBlockByNumber, rotating id), same ok / http_err / jsonrpc_err / stale / timeout classification.
- Keys live in the probe environment, never in the repo. Plan tiers, disclosed: Chainstack: a Global Node on the Growth plan, sponsored by Chainstack; QuickNode: an endpoint on the Mobula enterprise-tier account, shared fleet; Alchemy: a Free plan key (30M CU per month, 25 requests per second) normal signup, the tier any reader gets; Alchemy states free and paid keys share one routing; GetBlock: a Starter plan, 50M compute units per month shared by the two probe regions, 20 CU per call.
- GetBlock regional pairing: us-east uses GetBlock's New York endpoint and eu-west its Frankfurt endpoint. Alchemy, Chainstack and QuickNode publish one routed entry point per chain instead, which in the general case does land a probe on a nearby node. Some of any gap between the two arrangements is deployment topology rather than node speed, and a deployment in one of these regions would see the same benefit GetBlock's endpoint gives the probe.
- GetBlock coverage: GetBlock does not offer Arc in Singapore, so no GetBlock row exists for that region: the endpoint is not offered there, which is not a failed or pending measurement. The whole keyed cohort is therefore measured from us-east and eu-west, because averaging a two-region row against three-region rows would compare different populations.
- Two cohorts, two rankings: the public endpoints are shared, rate-limited gateways probed every 60 seconds; the keyed endpoints are metered or dedicated and probed every 120 seconds. The selector switches the whole page (ranking, chart, region tabs, badges, citation) between them. No figure on this page compares a public endpoint with a keyed one.
- Arc produces blocks in well under a second (Malachite BFT, sub-second finality). The stale check tolerates 40 blocks behind the cross-provider tip (20 s of wall clock) on the public cohort and 20 blocks on the keyed one.

## Perp DEX volume to open interest: 24h turnover per dollar of OI, live

- Category: Trading
- Metric: Volume / OI (24h) (x)
- Page: https://openchainbench.com/benchmarks/perp-volume-oi-ratio
- JSON: https://openchainbench.com/api/stat/perp-volume-oi-ratio
- Status: live
- Headline: Aevo posts the lowest volume / OI (24h) at 0.069x (p50, 24h) across 22 ranked venues.

**Rankings (p50, 24h):**
1. Aevo: 0.069x (p99 0.073x, success 82.8%, sample 2880)
2. Ostium: 0.208x (p99 0.286x, success 100.0%, sample 2880)
3. trade.xyz: 0.367x (p99 0.532x, success 80.0%, sample 2880)
4. Hyperliquid: 0.385x (p99 0.456x, success 100.0%, sample 2880)
5. dYdX v4: 0.432x (p99 1.055x, success 100.0%, sample 2880)
6. GMX v2: 0.517x (p99 0.733x, success 99.8%, sample 2880)
7. Paradex: 0.660x (p99 0.821x, success 100.0%, sample 2880)
8. Polymarket: 0.694x (p99 0.822x, success 80.0%, sample 2880)
9. GRVT: 0.902x (p99 1.018x, success 83.3%, sample 2880)
10. Aster: 0.949x (p99 1.141x, success 100.0%, sample 2880)
11. Jupiter Perps: 1.258x (p99 1.428x, success 80.0%, sample 2880)
12. Ondo Perps: 1.551x (p99 2.07x, success 80.0%, sample 2880)
13. edgeX: 1.561x (p99 1.896x, success 83.3%, sample 2880)
14. Nado: 1.869x (p99 3.60x, success 83.3%, sample 2880)
15. Lighter: 2.20x (p99 2.68x, success 100.0%, sample 2880)
16. Extended: 2.29x (p99 2.78x, success 98.5%, sample 2880)
17. Lighter RH: 2.40x (p99 2.81x, success 80.0%, sample 2880)
18. ApeX Omni: 2.75x (p99 2.78x, success 80.0%, sample 2880)
19. Pacifica: 4.88x (p99 5.70x, success 100.0%, sample 2880)
20. Gains: 5.68x (p99 6.89x, success 80.0%, sample 2880)
21. StandX: 8.84x (p99 9.97x, success 79.9%, sample 2880)
22. Kalshi: 20.1x (p99 23.9x, success 80.0%, sample 2880)

**Methodology**:
- Cadence: both gauges come from the perp-cohort-stats harness (every 60 seconds, one native call per venue); the ratio is computed in PromQL at query time from 24h time averages.
- Ratio = avg_over_time(perp_venue_volume_24h_usd[24h]) / avg_over_time(perp_venue_oi_usd[24h]), per venue. Volume is the venue's own rolling 24h notional; OI is the venue's own USD open interest (GMX v2: DefiLlama).
- Bands: 0.3x to 3x is the range of order-book venues with real position holders (Hyperliquid 0.5x, dYdX 1.3x, Lighter 2.5x on 2026-09-22); 1x to 4x for pool and oracle venues (Gains 1.4x, GMX v2 4.0x); above 8x the daily volume is many multiples of what stays open (Pacifica 8.5x, Kalshi 41x).
- Venues without one of the two series are excluded: Vest publishes no open interest; SynFutures, KiloEx, Orderly and Backpack publish no OI to the harness.
- Both terms are as the venue reports them. A venue counting both legs of every fill doubles its ratio against one that counts one; the bench does not normalise that, the venue formula on each row says what the API returns.
- Ranking sorts ascending (lower is first) so the venues whose volume is most backed by open positions lead; the subtitle and the bands are the reading, not the rank alone.
- A one-print spike does not move the board: both terms are 24h time averages of gauges sampled every minute.
- Why this ratio does not equal volume over open interest where both are shown beside it: the /capital open-interest table reads the latest value of these same two gauges, and this bench divides their 24-hour averages. Same gauges, same harness, different window, so a venue whose book moved during the day disagrees, by a lot on one that turns over in under an hour. Pages read the ratio from here rather than recomputing it, so one named ratio has one value across the site.

## Funding paid to hold an ETH perp long for 30 days, per venue, live

- Category: Trading
- Metric: Funding paid, 30d ETH long (bp)
- Page: https://openchainbench.com/benchmarks/perp-funding-cost-30d
- JSON: https://openchainbench.com/api/stat/perp-funding-cost-30d
- Status: live
- Headline: Bybit posts the lowest funding paid, 30d ETH long at 33.4 bps (30 days at the average daily rate) across 12 ranked venues.

**Rankings (p50, 30d):**
1. Bybit: 33.4 bps (p99 21.0 bps, success 100.0%, sample 702)
2. Deribit: 34.4 bps (p99 20.6 bps, success 100.0%, sample 702)
3. Binance: 34.5 bps (p99 13.6 bps, success 100.0%, sample 702)
4. Gate: 35.9 bps (p99 21.9 bps, success 100.0%, sample 702)
5. OKX: 37.7 bps (p99 27.8 bps, success 100.0%, sample 702)
6. MEXC: 38.5 bps (p99 30.7 bps, success 100.0%, sample 702)
7. KuCoin: 43.0 bps (p99 20.0 bps, success 100.0%, sample 702)
8. Bitget: 63.1 bps (p99 28.4 bps, success 100.0%, sample 702)
9. Kraken: 65.6 bps (p99 47.2 bps, success 100.0%, sample 702)
10. Lighter: 66.1 bps (p99 47.5 bps, success 100.0%, sample 720)
11. Hyperliquid: 83.6 bps (p99 59.4 bps, success 100.0%, sample 702)
12. Coinbase International: 103 bps (p99 149 bps, success 100.0%, sample 702)

**Methodology**:
- Source series: perp_venue_funding_24h_bps{venue,asset} from the perp-cohort-stats harness (each venue's own rate endpoint where the harness reads one: Kalshi, Vest, StandX, ApeX, Polymarket, Extended, edgeX, Pacifica, Aster, and Lighter since 2026-09-23, whose window before that date is the Mobula series for the same venue, identical at the switch; the Mobula funding aggregator for Hyperliquid and the CEX rows), sampled every 60 seconds and read here on an hourly grid ([30d:1h]).
- 30d cost = avg_over_time(series[30d:1h]) x 30: the average daily cost over the hours measured in the window, times a month. A venue is ranked only with 576 hourly samples (24 days) behind that average; under the floor the figure is a month at the rate of the days measured and the row carries its day count. 7d cost is avg_over_time(series[7d:1h]) x 7 (mean column).
- Columns: p50 = ETH 30d, p90 = BTC 30d, p99 = SOL 30d, mean = ETH 7d. The column labels are inherited from the latency template; the values are signed bps.
- Sign: positive means the long paid funding to shorts; negative means shorts paid longs. Lower ranks first, so on a month where shorts paid, the venue that paid longs the most is first.
- Sample health: expected_n is 720 (a month of hourly samples). A venue ranks only with 576 of them (24 days, 80 percent of the grid, which absorbs harness restarts): the figure does not move with coverage, but an average over a few days is not a month's evidence. Under the floor the row is unranked and shows its day count. A feed that stops loses its hours: the harness drops a rate nobody refreshed for five minutes rather than repeat it. Venues added on 2026-09-22 and 23 start under the floor.
- Interval normalisation is the venue's: Hyperliquid, Vest, StandX and ApeX settle hourly, Kalshi every 8 hours (three settlements a day), the CEX rows per their own schedule; every row is expressed as cost per 24h before integrating.
- This page does not replace perp-funding (bench 036), which ranks the rate right now; it ranks what the last month cost.

## Bridged TVL by chain: how much of a chain's capital came from somewhere else

- Category: Blockchains
- Metric: Bridged TVL (usd)
- Page: https://openchainbench.com/benchmarks/chain-bridged-tvl
- JSON: https://openchainbench.com/api/stat/chain-bridged-tvl
- Status: live
- Headline: Base leads bridged TVL at $8.36B (latest value) across 42 ranked chains.

**Rankings (p50, 24h):**
1. Base: $8.36B (p99 $8.36B, success 100.0%, sample 2880)
2. Arbitrum One: $8.20B (p99 $8.20B, success 100.0%, sample 2880)
3. Hyperliquid: $7.17B (p99 $7.17B, success 100.0%, sample 2880)
4. Polygon PoS: $3.90B (p99 $3.90B, success 100.0%, sample 2880)
5. Robinhood Chain: $1.97B (p99 $1.97B, success 100.0%, sample 2880)
6. Optimism: $1.61B (p99 $1.61B, success 100.0%, sample 2880)
7. Mantle: $1.43B (p99 $1.43B, success 100.0%, sample 2880)
8. World Chain: $534.55M (p99 $534.55M, success 100.0%, sample 2880)
9. Ink: $420.20M (p99 $420.20M, success 100.0%, sample 2880)
10. Linea: $377.17M (p99 $377.17M, success 100.0%, sample 2880)
11. Starknet: $363.91M (p99 $363.91M, success 100.0%, sample 2880)
12. Gnosis: $280.25M (p99 $280.25M, success 100.0%, sample 2880)
13. Ronin: $187.46M (p99 $187.46M, success 100.0%, sample 2880)
14. Morph: $164.56M (p99 $164.56M, success 100.0%, sample 2880)
15. Fraxtal: $158.08M (p99 $158.08M, success 100.0%, sample 2880)
16. zkSync Era: $135.85M (p99 $135.85M, success 100.0%, sample 2880)
17. X Layer: $134.39M (p99 $134.39M, success 100.0%, sample 2880)
18. Plume: $93.94M (p99 $93.94M, success 100.0%, sample 2880)
19. Unichain: $93.74M (p99 $93.74M, success 100.0%, sample 2880)
20. Manta Pacific: $64.96M (p99 $64.96M, success 100.0%, sample 2880)
21. BOB: $64.75M (p99 $64.75M, success 100.0%, sample 2880)
22. Abstract: $47.01M (p99 $47.01M, success 100.0%, sample 2880)
23. Scroll: $43.43M (p99 $43.43M, success 100.0%, sample 2880)
24. MegaETH: $35.06M (p99 $35.06M, success 100.0%, sample 2880)
25. Lisk: $29.33M (p99 $29.33M, success 100.0%, sample 2880)
26. Metis: $29.16M (p99 $29.16M, success 100.0%, sample 2880)
27. Immutable zkEVM: $29.12M (p99 $29.12M, success 100.0%, sample 2880)
28. ApeChain: $19.95M (p99 $19.95M, success 100.0%, sample 2880)
29. Celo: $19.57M (p99 $19.57M, success 100.0%, sample 2880)
30. Soneium: $19.08M (p99 $19.08M, success 100.0%, sample 2880)
31. Blast: $18.73M (p99 $18.73M, success 100.0%, sample 2880)
32. Gravity: $16.49M (p99 $16.49M, success 100.0%, sample 2880)
33. Taiko: $13.68M (p99 $13.68M, success 100.0%, sample 2880)
34. Arbitrum Nova: $12.57M (p99 $12.57M, success 100.0%, sample 2880)
35. Zircuit: $12.56M (p99 $12.56M, success 100.0%, sample 2880)
36. Polygon zkEVM: $10.14M (p99 $10.14M, success 100.0%, sample 2880)
37. Mode: $7.84M (p99 $7.84M, success 100.0%, sample 2880)
38. Boba Network: $6.60M (p99 $6.60M, success 100.0%, sample 2880)
39. Zora: $5.92M (p99 $5.92M, success 100.0%, sample 2880)
40. Reya Network: $4.53M (p99 $4.53M, success 100.0%, sample 2880)
41. Cyber: $3.01M (p99 $3.01M, success 100.0%, sample 2880)
42. Hemi: $1.12M (p99 $1.12M, success 100.0%, sample 2880)

**Methodology**:
- Source: L2Beat /api/scaling/summary, one unauthenticated request per tick covering every tracked project. Poll cadence 15 minutes, matched to the DefiLlama cadence in the same harness. Neither is the instant it is read at: DefiLlama publishes one daily TVL aggregate, and L2Beat computes an hourly series that normally runs one to two hours behind, so the page reports the last point each source finished rather than the moment of the request.
- Bridged TVL = canonical + external from tvs.breakdown, in USD. Canonical is value escrowed on the host chain by the chain's own contracts; external arrived through a third-party bridge; native was minted on the chain itself and is excluded.
- The three origins reconstruct the total, so bridged TVL is exactly the value secured that is not native, and a chain whose value is entirely canonical reads 100 percent bridged. A row whose origins miss its total by more than 0.1 percent is not published at all: if the upstream field names change, every one of them binds to zero, and a $0 bridged TVL at full health would be a wrong number that looks measured.
- Weekly move: L2Beat's own change7d on total value secured, converted from a ratio to a percentage. The excess subtracts the median change across every live project above $200M of value secured.
- The $200M floor exists because the median is a yardstick. L2Beat tracks about a hundred projects and most of them are small, so without a floor the many dust chains outnumber the rest and their moves, which are incentive programs rather than capital rotation, own the middle of the sorted list.
- Cohort composition: every live project above the floor votes, layer 3s and projects L2Beat currently has under review included. They are counted, not filtered, because dropping them would make the yardstick a judgement rather than a measurement; chain_tvs_cohort_size, _layer3 and _under_review publish the composition. Below five projects no median is published and the excess series is cleared rather than frozen.
- Rows: every chain in the OCB registry that carries an L2Beat project id, each verified against a live read of the endpoint. Several ids differ from the OCB slug (polygon-pos, zksync2, roninnetwork, worldchain, mantapacific, galxegravity, nova, polygonzkevm, bobanetwork, immutablezkevm).
- Membership: a row is a chain in the OCB chain registry that L2Beat tracks in its scaling summary, whatever category L2Beat files it under (42 of L2Beat's roughly 100 projects on 2026-09-25, Plume mapped that day); L2Beat projects outside the registry are not rows. Settled L1s carry no id because a chain with no host chain has no bridged balance to report.
- A project L2Beat has archived, one reporting a zero total, and one whose origins do not reconstruct that total all publish nothing: the chain's gauges are deleted rather than carried forward, so the row reads unresponsive within the hour, and chain_kpis_health{source="l2beat"} drops to 0 for that chain. That health series is the success column, so a row that stopped reporting also stops reading 100 percent.
- Freshness reads L2Beat's own chart.syncedUntil, not the Prometheus scrape and not the time of our fetch. The first is always seconds old because the harness re-exports carried-forward gauges; the second stays green when L2Beat answers 200 with stale numbers. A row whose weekly move is missing keeps its balance and loses only its two weekly columns, rather than publishing a flat week that never happened.
- Every aggregate column reads the latest value rather than a window statistic, so the board and the origin panels always describe the same instant. p50, p90, p99 and the mean are equal by construction; the sample count is the number of Prometheus scrapes in the 24h window (about 2,880 at a 30 second scrape), not a count of measurements, since the underlying value refreshes every 15 minutes.
- L2Beat's figures are a third-party measurement, credited as the source. OCB does not re-derive the escrow balances; this bench republishes the split and computes the cohort-relative move on top of it.

## Price to fees across DeFi: what the market pays per dollar of protocol fees

- Category: Trading
- Metric: P/F ratio (x)
- Page: https://openchainbench.com/benchmarks/protocol-pf-ratio
- JSON: https://openchainbench.com/api/stat/protocol-pf-ratio
- Status: live
- Headline: Pons posts the lowest P/F ratio at 0.202x (latest value) across 65 ranked protocols.

**Rankings (P/F, 24h):**
1. Pons: P/F 0.202x (success 100.0%, sample 1440)
2. Sanctum: P/F 0.291x (success 100.0%, sample 1440)
3. Securitize: P/F 0.346x (success 100.0%, sample 1440)
4. Meteora: P/F 0.390x (success 100.0%, sample 1440)
5. StonkFun: P/F 0.446x (success 100.0%, sample 1440)
6. Graphite Protocol: P/F 0.544x (success 100.0%, sample 1440)
7. Quickswap: P/F 0.580x (success 100.0%, sample 1440)
8. Lido: P/F 0.598x (success 100.0%, sample 1440)
9. Gains Network: P/F 0.993x (success 100.0%, sample 1440)
10. Raydium: P/F 1.031x (success 100.0%, sample 1440)
11. Dolomite: P/F 1.048x (success 100.0%, sample 1440)
12. Orca: P/F 1.106x (success 100.0%, sample 1440)
13. Rocket Pool: P/F 1.257x (success 100.0%, sample 1440)
14. Pump: P/F 1.340x (success 100.0%, sample 1440)
15. Centrifuge: P/F 1.361x (success 100.0%, sample 1440)
16. Chainflip: P/F 1.375x (success 100.0%, sample 1440)
17. GMX: P/F 1.414x (success 100.0%, sample 1440)
18. Stader: P/F 1.545x (success 100.0%, sample 1440)
19. Benqi: P/F 1.555x (success 100.0%, sample 1440)
20. stake.link: P/F 1.573x (success 100.0%, sample 1440)
21. Euler: P/F 1.617x (success 100.0%, sample 1440)
22. NAVI Protocol: P/F 1.948x (success 100.0%, sample 1440)
23. USD AI: P/F 1.963x (success 100.0%, sample 1440)
24. Lista DAO: P/F 2.08x (success 100.0%, sample 1440)
25. Ekubo Protocol: P/F 2.35x (success 100.0%, sample 1440)
26. Maple Finance: P/F 2.47x (success 100.0%, sample 1440)
27. Cetus: P/F 2.61x (success 100.0%, sample 1440)
28. BONK.fun: P/F 2.77x (success 100.0%, sample 1440)
29. Uniswap: P/F 2.86x (success 100.0%, sample 1440)
30. o1.exchange: P/F 2.92x (success 100.0%, sample 1440)
31. Rhea Finance: P/F 2.95x (success 100.0%, sample 1440)
32. Venus: P/F 2.99x (success 100.0%, sample 1440)
33. PancakeSwap: P/F 2.99x (success 100.0%, sample 1440)
34. HumidiFi: P/F 3.21x (success 100.0%, sample 1440)
35. edgeX: P/F 3.37x (success 100.0%, sample 1440)
36. Aerodrome: P/F 3.61x (success 100.0%, sample 1440)
37. Kinetiq: P/F 3.64x (success 100.0%, sample 1440)
38. Frax Finance: P/F 3.66x (success 100.0%, sample 1440)
39. CoWSwap: P/F 3.76x (success 100.0%, sample 1440)
40. Re: P/F 3.86x (success 100.0%, sample 1440)
41. Kamino: P/F 3.90x (success 100.0%, sample 1440)
42. Definitive: P/F 3.92x (success 100.0%, sample 1440)
43. Fluid: P/F 3.95x (success 100.0%, sample 1440)
44. KyberSwap: P/F 4.38x (success 100.0%, sample 1440)
45. ether.fi: P/F 4.54x (success 100.0%, sample 1440)
46. Jupiter: P/F 5.29x (success 100.0%, sample 1440)
47. Moonwell: P/F 5.38x (success 100.0%, sample 1440)
48. Aave: P/F 6.22x (success 100.0%, sample 1440)
49. THORChain DEX: P/F 6.23x (success 100.0%, sample 1440)
50. Convex Finance: P/F 7.30x (success 100.0%, sample 1440)
51. Morpho: P/F 7.90x (success 100.0%, sample 1440)
52. ApeX Protocol: P/F 8.09x (success 100.0%, sample 1440)
53. Compound Finance: P/F 8.21x (success 100.0%, sample 1440)
54. Velodrome: P/F 9.81x (success 100.0%, sample 1440)
55. Sushi: P/F 11.0x (success 100.0%, sample 1440)
56. World Liberty Financial: P/F 11.9x (success 100.0%, sample 1440)
57. Curve Finance: P/F 12.5x (success 100.0%, sample 1440)
58. Lighter: P/F 15.7x (success 100.0%, sample 1440)
59. cap: P/F 18.5x (success 100.0%, sample 1440)
60. Hyperliquid: P/F 19.3x (success 100.0%, sample 1440)
61. Aster: P/F 30.7x (success 100.0%, sample 1440)
62. Ondo Finance: P/F 31.3x (success 100.0%, sample 1440)
63. SUN: P/F 33.9x (success 100.0%, sample 1440)
64. JustLend: P/F 60.2x (success 100.0%, sample 1440)
65. Pendle: P/F 60.3x (success 100.0%, sample 1440)

**Methodology**:
- Board membership. A token whose fee adapter is knowably incomplete (protocol_fees_incomplete = 1: the adapter reports $0 over 30 days after a year of fees, so the ratio would be built on a fraction of the protocol) is metered but not listed; on 2026-09-25 that is Drift, Bluefin and DoubleZero. The peer median of each category is a live gauge (protocol_category_pf_median), read on the vs-category tab, never a number typed here.
- P/F = circulating market cap / annualized fees, where annualized fees are the trailing 30 day sum x 365/30. Same cut as benches 234 and 265, so the three valuation boards stay comparable.
- Fees are the total DeFiLlama reports for the protocols behind the token, summed across every adapter: Uniswap V2, V3 and V4 are one row, GMX's five products are one row. Ranking them apart would divide one market cap by a fraction of its own revenue. Total, not revenue: most of a DEX's fees go to liquidity providers and most of a staking protocol's to stakers, so this is what users paid, not what the token earns.
- The token is resolved through DeFiLlama's own links, not by name matching: the adapter's defillamaId joins to /protocols, and when that row carries no CoinGecko id the parent protocol from /config does.
- Category: the one carrying most of the token's fees, not the one its first-listed adapter sits in. Drift files a small spot product under Dexs and earns most of its fees on perps, so taking the first would compare it to liquid staking protocols and drag their median with it.
- Peer comparison: each row carries the median P/F of its category, and protocol_pf_vs_category_ratio is the row divided by that median. A category needs at least 5 tokens before a median is published; a row in a smaller category shows its ratio with no comparison rather than a comparison against one or two protocols.
- Market cap floor: 5 million USD of circulating market cap. Below it the ratio is not a valuation: a token worth a few hundred thousand dollars against millions of annual fees prints a multiple near zero and would lead an ascending board as the cheapest token in DeFi, when it is an abandoned or unlisted one. Fifteen of the top twenty rows sat under 10 million before this floor (2026-09-25).
- Float floor: a token with less than 10 percent of supply circulating is not ranked. Its market cap is a fraction of what the token will be, so the ratio reads near zero and would lead an ascending board.
- Fee floor: 100,000 USD of trailing 30 day fees, applied to the token after its adapters are summed rather than to each adapter. A token whose products only clear the floor together belongs on the board, and a multi-product token must not lose its smaller products out of its own denominator.
- The board shows the largest fee earners; a row whose category has fewer than 5 tokens carries its ratio with no peer comparison. The harness publishes every row that clears the floors, so the cut is editorial and the full set is queryable.
- A protocol whose fee history is shorter than the windows is not ranked: when every fee its adapters ever reported falls inside the trailing 30 days (protocol_fees_window_short = 1), x 365/30 would overstate the run rate, so the row is metered with protocol_fees_incomplete = 1 and leaves the board and the median until a full window exists.
- Fees and revenue are two views of one business, so they move together. When one grows half again as much as the other over the same month, what changed is what is being counted: protocol_fee_basis_shift marks the row and its fee trend is withheld for a month afterwards, because the seam sits in the prior window that long. DefiLlama rewrote the Convex adapter on 2026-08-18 without backfilling, printing 92 percent on a business that grew 15.
- The month-over-month trend needs a full prior month: it publishes only when the year total reaches past both windows, so a 40-day-old adapter is ranked with no trend rather than with growth measured against ten days.
- A token with a fee adapter reporting nothing over 30 days after real fees over the year has a published total short of its revenue, and is excluded from the board, from its category median and from the screen. DeFiLlama's Drift Trade adapter is in that state: it reports $0 after $11.1M over the year, so only Drift's $1.2M staking product reaches the token. protocol_fees_incomplete and protocol_silent_adapter_fees_1y_usd publish the flag and the size of the gap.
- protocol_diverging is 1 when three things hold at once: fees grew month over month, the token fell over 30 days, and the P/F sits below the category median. The third clause is what stops it naming every protocol having a bad month.
- The /capital hub screens the same rows harder, four clauses instead of three: fee growth above 20% (the cohort median was +21% on 2026-09-29, so at or under it a row grew no faster than the median protocol), a token move beyond 10% (20 of the 67 ranked tokens moved less inside 30 days), the P/F on the right side of the category median, and at least 5 ranked protocols in the category, since a median over 2 compares the token with one other. Every clause is checkable from that page's columns.
- Revenue 30d (protocol_revenue_30d_usd): the share of fees the protocol keeps, per each adapter's own definition on DeFiLlama (/overview/fees with dataType=dailyRevenue), summed over the adapters the fees come from. Absent when no adapter behind the token publishes a revenue series: that is unknown, not zero. Published as 0 when the adapters have one and report none.
- protocol_revenue_incomplete is 1 when the revenue total is knowably short: the fee total itself is short, a revenue adapter reports nothing over 30 days after real revenue over the year, or a product earning fees this month has no revenue series while its siblings do (protocol_revenue_missing_adapters counts them). Revenue is published with the flag; the P/S built on it is not, because a multiple on a fraction of the revenue reads higher than it is.
- P/S (protocol_ps_ratio) = circulating market cap / annualized revenue, revenue being the trailing 30 day sum x 365/30. The same multiple as P/F on what the token's protocol keeps rather than on what its users paid. Absent when revenue is missing, zero or knowably short, so no row reads as infinitely priced, as free, or as pricier than it is.
- TVL (protocol_tvl_usd): DeFiLlama /protocols tvl summed over every row that resolves to the token by the same rule as the fee adapters, its own CoinGecko id first, else its parent's, so Aave V2, V3 and Horizon count once each under AAVE. Absent when no row carries a TVL: a launchpad or a perp DEX settling on its own chain has nothing locked, and that is not a zero.
- Supply 30d and 90d (protocol_supply_change_30d_pct, protocol_supply_change_90d_pct): circulating supply now against 30 and 90 days ago, in percent. Source: CoinGecko /market_chart, 91 days of daily market cap and price per token; their ratio is the circulating supply CoinGecko held that day. Absent while the series is shorter than the window. One CoinGecko call per token per UTC day, cached in memory.
- Supply change is realized dilution, not an unlock schedule. A positive figure is supply that reached the float over the window (unlocks, emissions), a negative one a burn. A cliff next month is invisible here until it lands, and a token that unlocked last week shows it in the 30 day column before the 90 day one catches up.
- Cadence: hourly. DeFiLlama's fee series is daily and CoinGecko's free tier is rate limited, so a faster poll would spend requests re-reading numbers that have not moved. p50, p90, p99 and the mean read the same gauge and are equal by construction.
- The cohort is rebuilt from upstream every poll and the per-protocol series are reset with it, so a token that is delisted or drops below a floor loses its row rather than carrying a stale valuation forward.

## Stablecoin flow by chain: where dollars actually moved over 30 days

- Category: Blockchains
- Metric: Net stablecoin flow (30d) (usd)
- Page: https://openchainbench.com/benchmarks/chain-stablecoin-flow
- JSON: https://openchainbench.com/api/stat/chain-stablecoin-flow
- Status: live
- Headline: TRON leads net stablecoin flow (30d) at $1.72B (latest value) across 26 ranked chains.

**Rankings (p50, 24h):**
1. TRON: $1.72B (p99 $1.72B, success 100.0%, sample 2880)
2. Plasma: $488.50M (p99 $488.50M, success 100.0%, sample 2880)
3. Hyperliquid: $448.82M (p99 $448.82M, success 100.0%, sample 2880)
4. Solana: $370.36M (p99 $370.36M, success 100.0%, sample 2880)
5. Base: $275.12M (p99 $275.12M, success 100.0%, sample 2880)
6. Arbitrum One: $246.10M (p99 $246.10M, success 100.0%, sample 2880)
7. XRP Ledger: $186.07M (p99 $186.07M, success 100.0%, sample 2880)
8. Robinhood Chain: $148.71M (p99 $148.71M, success 100.0%, sample 2880)
9. Optimism: $83.39M (p99 $83.39M, success 100.0%, sample 2880)
10. Sui: $56.07M (p99 $56.07M, success 100.0%, sample 2880)
11. Stellar: $29.17M (p99 $29.17M, success 100.0%, sample 2880)
12. Ink: $15.50M (p99 $15.50M, success 100.0%, sample 2880)
13. Avalanche: $14.96M (p99 $14.96M, success 100.0%, sample 2880)
14. Sei: $6.97M (p99 $6.97M, success 100.0%, sample 2880)
15. Starknet: $2.16M (p99 $2.16M, success 100.0%, sample 2880)
16. Celo: $527.3K (p99 $527.3K, success 100.0%, sample 2880)
17. Sonic: -$5.12M (p99 -$5.12M, success 100.0%, sample 2880)
18. Mantle: -$17.40M (p99 -$17.40M, success 100.0%, sample 2880)
19. Monad: -$31.08M (p99 -$31.08M, success 100.0%, sample 2880)
20. Gram: -$37.03M (p99 -$37.03M, success 100.0%, sample 2880)
21. Cronos: -$48.77M (p99 -$48.77M, success 100.0%, sample 2880)
22. BNB Chain: -$57.31M (p99 -$57.31M, success 100.0%, sample 2880)
23. Aptos: -$80.16M (p99 -$80.16M, success 100.0%, sample 2880)
24. Polygon PoS: -$152.48M (p99 -$152.48M, success 100.0%, sample 2880)
25. X Layer: -$157.25M (p99 -$157.25M, success 100.0%, sample 2880)
26. Ethereum: -$912.68M (p99 -$912.68M, success 100.0%, sample 2880)

**Methodology**:
- Source: DefiLlama /stablecoincharts/<chain>, the chain-wide pegged-USD aggregate across every issuer, one point per day. Unfiltered: adding stablecoin=<id> narrows to a single asset and returns an empty 200 on chains where that asset has no issuance.
- Net flow = today's float minus the float 30 days earlier, in dollars. The percentage is the same difference over the earlier value. Both windows count back by index on the daily series, so 7d is the point seven days back and not eight.
- A window is published only when the series reaches that far back and the starting value is above zero. A chain newly tracked, or one whose float started at zero, publishes its float gauge but no 30-day figure, so it is not ranked until the window exists rather than ranked on an invented move.
- Size floor: $100M of stablecoin float, applied when the cohort was chosen rather than recomputed each run. Below it a single mint or redemption moves the percentage by tens of points, and the board would rank issuance events rather than capital movement.
- Ranking is by net dollars, because that is the quantity that actually moved. The percentage column is the size-adjusted reading and the two disagree on purpose: the largest net inflow and the largest percentage gain are rarely the same chain.
- No cohort-relative column here, unlike bench 273. A flow already carries a sign, so the raw number separates a chain that gained from one that lost. Value secured is a level and moves with the market, which is why that board needs an excess column and this one does not.
- Cadence: every 15 minutes, matched to the rest of the DefiLlama reads in the harness. The underlying series is daily, so p50, p90, p99 and the mean read the same value and are equal by construction.
- Coverage: every registry chain DefiLlama tracks for stablecoins that sat above the floor on 2026-09-25, when the cohort was chosen; the Results heading carries the live count. A chain DefiLlama does not track answers 404 and is absent rather than shown at zero. Arc cleared the floor but its history starts 2026-09-17, too short to difference; it joins once that point exists. Under the floor that day: Berachain, zkSync Era, Linea, Unichain, Gnosis.

## Prediction market open interest: where capital actually sits

- Category: Trading
- Metric: Open interest (usd)
- Page: https://openchainbench.com/benchmarks/pm-open-interest
- JSON: https://openchainbench.com/api/stat/pm-open-interest
- Status: live
- Headline: Kalshi leads open interest at $1.07B (24h) across 12 ranked venues.

**Rankings (p50, 24h):**
1. Kalshi: $1.07B (p99 $1.12B, success 100.0%, sample 2880)
2. Polymarket: $336.82M (p99 $348.06M, success 100.0%, sample 2880)
3. Rain: $20.71M (p99 $21.86M, success 100.0%, sample 2880)
4. Predict Fun: $9.94M (p99 $10.66M, success 100.0%, sample 2880)
5. OPINION: $3.22M (p99 $3.25M, success 100.0%, sample 2880)
6. Sport.fun: $2.37M (p99 $2.39M, success 100.0%, sample 2880)
7. Augur: $2.11M (p99 $2.12M, success 100.0%, sample 2880)
8. Levr Bet: $1.88M (p99 $1.88M, success 100.0%, sample 2880)
9. Pascal: $1.78M (p99 $1.79M, success 100.0%, sample 2880)
10. PredictStreet: $1.54M (p99 $1.60M, success 100.0%, sample 2880)
11. Overtime: $1.26M (p99 $1.28M, success 100.0%, sample 2880)
12. Trueo: $843.4K (p99 $844.3K, success 100.0%, sample 2880)

**Methodology**:
- Open interest here is collateral: cash held against positions still open, not their market value. On the on-chain venues that is DefiLlama protocol TVL, one dollar escrowed per complete set outstanding. On Kalshi it is one dollar per open contract, since each settles at a dollar or nothing and is fully collateralized across the two sides. Each row tag names its source.
- Valuing Kalshi's open contracts at last price instead gives the market value of the YES leg. That is a different quantity (14% of the collateral figure on 2026-09-23), and it is published as pm_venue_open_interest_mark_usd rather than dropped. Myriad's native figure is AMM liquidity, not positions.
- Volume: each venue's own figure where its API gives one, otherwise DefiLlama /summary/dexs for that protocol. Both windows, 24 hours and 30 days, come from the same source for a given venue so the ratio between them is internally consistent.
- Turnover is 24h volume over open interest. Below 1x a venue holds more than it trades in a day, which is what long-dated markets look like; well above 1x the book turns over repeatedly, which is what short-dated contracts look like. It is a description, not a ranking.
- Kalshi's volume comes from DefiLlama rather than from the harness's own read. Unauthenticated, the fetcher sums the /events catalog and reaches $2.26M against DefiLlama's $424.8M for the same venue and window on 2026-09-23, because the catalog walk is capped well short of the full book. With an API key the native figure is the better source and the harness prefers it again.
- Polymarket's 24h volume is DefiLlama's. The harness also walks gamma, and that walk is truncated, not exhausted: gamma caps limit at 100 however much you ask for, and refuses offsets past 2100 with a 422 naming /markets/keyset for deeper pagination. The walk therefore stops at exactly 2,100 markets and $5.37M against DefiLlama's $61.8M, and the same cut is why no active-market count is published for Polymarket. Measured against gamma directly on 2026-09-23.
- Size floor: $500,000 of open interest. Below it one position moves a venue by tens of percent, and the board would rank position-opening events. Venues under the floor keep publishing their gauges and are absent from the ranking.
- A venue with no readable open interest is absent rather than shown at zero. Polymarket US is in that state: a CFTC-regulated exchange has no on-chain balance for DefiLlama to measure, and while its own API does publish per-market open interest, reading it costs one request per market. Its volume is among the largest in the category and is published.
- Cadence: native fetchers every 5 minutes, the DefiLlama aggregate every 15. The headline is a 24h average, so a single print does not move a row.
- Two known limits on the Kalshi figure, stated rather than smoothed. Its catalog walk covers 13,402 open events and 125,777 nested markets, and markets that have already resolved inside a still-open event are excluded (2,229 of them, holding 48.5M contracts, on 2026-09-23). And Kalshi offers reduced margin across mutually exclusive outcomes in one event group, so $1 per open contract is an upper bound on cash actually escrowed; the exchange publishes no netted figure.

## Tokenized RWA on Solana, what a $100k sale actually costs

- Category: RWA
- Metric: Cost of a $100k sale (bp)
- Page: https://openchainbench.com/benchmarks/rwa-solana-depth
- JSON: https://openchainbench.com/api/stat/rwa-solana-depth
- Status: live
- Headline: USDY posts the lowest cost of a $100k sale at 3.64 bps (p50, 24h) across 14 ranked tokenized assets.

**Rankings (Cost $100k, 24h):**
1. USDY: Cost $100k 3.64 bps, p99 $100k 3.64 bps (success 84.2%, sample 2424)
2. SPYx: Cost $100k 9.48 bps, p99 $100k 17.2 bps (success 98.6%, sample 2840)
3. NVDAx: Cost $100k 13.1 bps, p99 $100k 60.9 bps (success 94.5%, sample 2723)
4. PAXG: Cost $100k 17.2 bps, p99 $100k 143 bps (success 100.0%, sample 2880)
5. TSLAx: Cost $100k 21.2 bps, p99 $100k 92.5 bps (success 98.5%, sample 2836)
6. QQQx: Cost $100k 38.4 bps, p99 $100k 98.5 bps (success 98.6%, sample 2840)
7. GOOGLx: Cost $100k 75.6 bps, p99 $100k 102 bps (success 100.0%, sample 2880)
8. METAx: Cost $100k 84.2 bps, p99 $100k 114 bps (success 100.0%, sample 2880)
9. MSFTx: Cost $100k 89.0 bps, p99 $100k 116 bps (success 100.0%, sample 2880)
10. AAPLx: Cost $100k 154 bps, p99 $100k 178 bps (success 100.0%, sample 2880)
11. HOODx: Cost $100k 156 bps, p99 $100k 187 bps (success 100.0%, sample 2880)
12. COINx: Cost $100k 171 bps, p99 $100k 209 bps (success 100.0%, sample 2880)
13. AMZNx: Cost $100k 180 bps, p99 $100k 237 bps (success 100.0%, sample 2880)
14. PLTRx: Cost $100k 836 bps, p99 $100k 977 bps (success 100.0%, sample 2880)

**Methodology**:
- Quotes: Jupiter lite-api /swap/v1/quote, token to USDC, slippage 100 bps, one route search per size, 5 seconds apart (the free tier allows 60 requests a minute per address, shared with the sibling harnesses). Four quotes per routed asset per tick: $100 (reference, sized at the previous tick's price), then $1k, $10k and $100k sized at this tick's reference price; the cost is a ratio of two quotes a few seconds apart on the same tick.
- Cost = 10000 x (1 - USDC received per raw unit at the size / USDC received per raw unit at $100), in basis points. Positive is a worse price at size, the normal case; a small negative reading happens when a larger sale reaches a better pool split than the $100 quote. Published as rwa_depth_cost_1k_bps, rwa_depth_cost_10k_bps and rwa_depth_cost_100k_bps per asset; a size Jupiter could not route this tick has its gauge deleted, never held.
- Headline: 24-hour median of the $100k cost (quantile_over_time 0.5), p90 and p99 of the same series; the $1k and $10k 24-hour medians are panels. Ranked lowest first. rwa_depth_route_ok is 1 on a tick where the $100k sale was priced and 0 otherwise (no route, or a quote that failed); its 24-hour average is the row's success, and the site ranks a row above 50 percent.
- On-chain supply: getTokenSupply on the mint every ten minutes through a keyed Solana RPC, published as rwa_onchain_supply_units and, valued at the $100 executable price per raw unit, rwa_onchain_supply_usd. Raw units on both sides, so a Token-2022 scaled-UI mint (seven xStocks) needs no multiplier. BUIDL is valued at its designed $1.00 per unit (dividends are paid in new units); USTB on Solana has no price this page can defend, so only its unit supply is shown.
- Cohort: USDY (Ondo), PAXG (Paxos), the 12 xStocks the xstocks-peg bench prices, and two funds with no open market listed unranked: BUIDL (BlackRock, mint GyWgeqpy...w6phr) and USTB (Superstate, the Invesco Short Duration US Government Securities Fund, mint CCz3SGVz...Vcjo2 from Superstate's contract list). OUSG's Solana mint had zero supply on 2026-09-23 and is out. Mints come from the issuers' documentation, not from a token-list search, which returns look-alikes for every fund.
- What the cost is and is not: it is the price a seller gets from the open market on Solana today, routes and fees included, at the moment of the tick; it is not a redemption cost through the issuer (USDY, BUIDL and USTB redeem at NAV on the issuer's schedule) and not a statement about the asset's backing. A fund with no route is not broken: it is not sold on an open market by design, which is precisely the fact this page adds to the declared total.
- Reproducibility: harness source at github.com/ChainBench/OpenChainBench/tree/main/harnesses/rwa-solana-depth; every quote URL is public and keyless, the supply read needs any Solana RPC that serves getTokenSupply.

## Trading terminal execution quality 2026: what a swap costs once the app's own fee is removed

- Category: Trading
- Metric: Execution loss (bp)
- Page: https://openchainbench.com/benchmarks/terminal-execution-quality
- JSON: https://openchainbench.com/api/stat/terminal-execution-quality
- Status: live
- Headline: FOMO posts the lowest execution loss at 188 bps (p50, 24h) across 10 ranked providers.

**Rankings (Execution loss, 24h):**
1. FOMO: Execution loss 188 bps (success 100.0%, sample 590)
2. pump.fun app: Execution loss 229 bps (success 100.0%, sample 285)
3. GMGN: Execution loss 233 bps (success 100.0%, sample 466)
4. BONKbot: Execution loss 261 bps (success 100.0%, sample 134)
5. Terminal: Execution loss 284 bps (success 100.0%, sample 136)
6. Trojan: Execution loss 292 bps (success 100.0%, sample 112)
7. Axiom: Execution loss 315 bps (success 100.0%, sample 249)
8. Pepeboost: Execution loss 340 bps (success 100.0%, sample 130)
9. Maestro: Execution loss 342 bps (success 100.0%, sample 417)
10. Bloom: Execution loss 383 bps (success 100.0%, sample 261)

**Methodology**:
- The measurement is bench 268's, with one subtraction. Every detail of sampling, user attribution, quote handling, pool identity, reference price and loss bounds is that bench's; see its methodology. Nothing is re-read from chain and no additional RPC is spent.
- Execution loss = loss − terminal fee, computed on each swap, then the median over the window. The subtraction happens before the quantile, never after: median(loss) − median(terminal) is a different number, and the gap is largest on an app whose fee differs across its own swaps (FOMO charges 2 % on Solana and about 0.5 % through Relay). It moves with the cohort from one refresh to the next, so read it from the two columns on the board rather than from any figure quoted here.
- What is removed is the terminal's own cut: what reached its fee wallets on Solana, the router's residual after the pool and the gas on the EVM rows, the app fee on Relay legs. Referral and cashback legs count as terminal fee where the terminal's list holds them.
- What stays in: network (transaction fee the user paid, inclusion tips including the terminal's own relay, the deposit of token accounts the swap creates), pool (the final pool's LP fee and price impact) and protocol (launchpad and curve fees, router cuts, referral payouts). Each is a consequence of how the app routed the trade, not of what it charges for doing so.
- A swap whose fee exceeded its loss reads negative: a rebated fee, or a reference that moved in the user's favour between the previous trade and this one. Those swaps are kept: removing them would trim the left tail and push every median up.
- Publication and ranking follow bench 268 exactly: same floors, same health and ranked flags, same per-chain pooling weighted by flow. A product present on one board is present on the other, so the two can be read side by side without a row appearing in only one of them.
- The two rankings differ: a product whose fee sits far from the cohort's usual 1 % changes place once the fee comes out, in either direction. How far each row moved is read from the two live columns, not from this sentence. Read this board with the 95 % interval under each median. As on bench 268, most adjacent pairs are not separated by the measurement.

## Answers (41 question pages)

Each page answers one question from a live benchmark and publishes its methodology and its limits. Cite the answer URL when the question is the claim; cite the benchmark URL when the measurement is.

### Which prediction market is best for politics and elections?

- Page: https://openchainbench.com/answers/best-prediction-market-for-politics
- Benchmark: https://openchainbench.com/benchmarks/pm-resolution-delay
- Answer: Polymarket carries the highest global volume on political and election markets, with the largest open interest in the cohort. Politics markets have the longest resolution delay on Polymarket at 180.3 min median, because they wait for authoritative sources before resolving. For US users, Kalshi is the regulated option with political event contracts. Metaculus is free and tracks calibration but is not real-money.

### Which prediction market is best for sports?

- Page: https://openchainbench.com/answers/best-prediction-market-for-sports
- Benchmark: https://openchainbench.com/benchmarks/pm-resolution-delay
- Answer: For non-US users, Polymarket has the deepest sports books and the widest market variety. Sports resolution on Polymarket currently runs 57.8 min median from first onchain proposal. For US users, Kalshi is the only CFTC-regulated real-money option with NFL, NBA and other sports coverage. Manifold has sports markets but is play-money.

### Which RPC is best for indexers and high-throughput read workloads in 2026?

- Page: https://openchainbench.com/answers/best-rpc-for-indexer
- Benchmark: https://openchainbench.com/benchmarks/rpc-capabilities
- Answer: Binance currently ranks first on the free-tier keyed RPC leaderboard at 32 ms p50 latency (24h avg) on eth_getBlockByNumber probes, and pairs it with archive-depth support across a wide chain footprint, measured live by OpenChainBench from three regions.

### Which bridge is cheapest to move USDC to Base?

- Page: https://openchainbench.com/answers/cheapest-bridge-usdc-to-base
- Benchmark: https://openchainbench.com/benchmarks/bridge-fee
- Answer: OpenChainBench measures the all in cost of a $300 USDC bridge (fee plus slippage plus destination gas) across eight routers: Mobula, Relay, LI.FI, deBridge, Across, Near Intents, Squid and Socket. Since the bench aggregates across the Solana, Base and Arbitrum corridors, the USDC-to-Base leader on a specific corridor is on the per corridor breakdown at openchainbench.com/benchmarks/bridge-fee.

### dRPC vs PublicNode vs 1RPC, which no-key public RPC is fastest?

- Page: https://openchainbench.com/answers/drpc-vs-publicnode-vs-1rpc
- Benchmark: https://openchainbench.com/benchmarks/rpc-capabilities
- Answer: Between the three providers, dRPC and PublicNode trade the top two spots by chain and region; 1RPC was delisted 2026-07-09 for a sustained sub-13% success rate and is pinned below the ranked table. On the wider 15-provider board, chain-official gateways (Binance, Base, Avalanche) often post faster aggregate p50. Live per-chain and per-region ranking at openchainbench.com/benchmarks/rpc-capabilities.

### How long does Polymarket take to resolve a market?

- Page: https://openchainbench.com/answers/how-long-does-polymarket-take-to-resolve
- Benchmark: https://openchainbench.com/benchmarks/pm-resolution-delay
- Answer: Measured onchain, the median Polymarket market currently resolves 88.0 min after the first outcome proposal reaches UMA's oracle, with the slowest 1% taking 238.1 min or more. The clock starts at the proposal, not when the real world event ends, so the total wait you experience is at least these figures. Winning shares are redeemable immediately after onchain resolution.

### How much does it cost to bridge USDC to Arbitrum?

- Page: https://openchainbench.com/answers/how-much-does-it-cost-to-bridge-usdc-to-arbitrum
- Benchmark: https://openchainbench.com/benchmarks/bridge-fee
- Answer: On a $300 USDC transfer, the cheapest measured provider currently lands at 0.013% of notional all in (Socket Protocol, p50 over 24h) and the most expensive at 1.15%, measured live by OpenChainBench across USDC corridors spanning Solana, Base and Arbitrum, including the Base to Arbitrum route. All in means fees plus slippage plus destination gas, the number that actually leaves your wallet.

### Is Polymarket safe to use?

- Page: https://openchainbench.com/answers/is-polymarket-safe
- Benchmark: https://openchainbench.com/benchmarks/pm-api-latency
- Answer: Polymarket's custody model is safer than a centralized exchange: funds are held as USDC in audited smart contracts on Polygon, not in a company bank account. OpenChainBench measures Polymarket API uptime live at 94 ms warm latency with near-100% uptime historically. Smart contract risk and Polygon network risk exist, as with any onchain protocol. This page covers infrastructure and custody safety, not investment advice.

### Is Solana staking better than Ethereum staking?

- Page: https://openchainbench.com/answers/is-solana-staking-better-than-ethereum
- Benchmark: https://openchainbench.com/benchmarks/validator-yield
- Answer: On raw yield, currently yes: Solana validators pay a median net 4.88% (24h) versus 2.51% for a network average Ethereum solo validator, measured live by OpenChainBench. The comparison carries caveats in both directions: the Ethereum figure excludes MEV and execution tips, and the Solana median is dragged down by validators currently paying 0%.

### Is USDC safer than USDT?

- Page: https://openchainbench.com/answers/is-usdc-safer-than-usdt
- Benchmark: https://openchainbench.com/benchmarks/stablecoin-peg
- Answer: On measured peg stability, the live data is on this page: USDC currently shows 0.017% worst case deviation (p99, 24h) versus 0.042% for USDT on USD quoted venues, measured live by OpenChainBench. Peg tightness is the market's real time verdict, but safety is broader: reserve composition, redemption terms and regulatory posture differ between Circle and Tether, and none of those appear in a price feed.

### Manifold Markets vs Polymarket, which should you use?

- Page: https://openchainbench.com/answers/manifold-markets-vs-polymarket
- Benchmark: https://openchainbench.com/benchmarks/pm-api-latency
- Answer: They serve different use cases. Manifold uses play-money (mana) with no real financial risk, is US-accessible, and explicitly welcomes developers and bots. Polymarket uses real USDC on Polygon, has the deepest real-money books, and is geoblocked for US users on the international exchange. API latency: Polymarket at 94 ms p50, Manifold at 112 ms p50 origin (CDN-cached responses excluded).

### Polymarket vs Kalshi, which resolves prediction markets faster?

- Page: https://openchainbench.com/answers/polymarket-vs-kalshi-resolution-speed
- Benchmark: https://openchainbench.com/benchmarks/pm-resolution-delay
- Answer: OpenChainBench measures Polymarket resolution delay directly onchain on Polygon: median across sports, politics and crypto categories is in the tens of minutes today, with crypto markets fastest and politics slowest by a wide margin. Kalshi settlement is offchain through a CFTC-registered exchange and is not yet in the harness; the venue-versus-venue head-to-head on this page will populate as soon as Kalshi settlement events are ingested. Live numbers per category at openchainbench.com/benchmarks/pm-resolution-delay.

### Which prediction market API is best for developers?

- Page: https://openchainbench.com/answers/prediction-market-api-for-developers
- Benchmark: https://openchainbench.com/benchmarks/pm-api-latency
- Answer: For trading bots: Polymarket (public WebSocket, deepest CLOB, 94 ms p50) or Kalshi (documented API contract, CFTC-regulated). For dashboards and research: Manifold (500 req/min, explicit bot welcome, 112 ms p50 origin) or Kalshi (most stable docs). Current latency leader across the cohort: Polymarket at 94 ms p50.

### What is the fastest free Arbitrum RPC?

- Page: https://openchainbench.com/answers/what-is-the-fastest-free-arbitrum-rpc
- Benchmark: https://openchainbench.com/benchmarks/arbitrum-rpc
- Answer: dRPC is currently the fastest free Arbitrum RPC at 63 ms (eth_getBlockByNumber p50, 24h), measured by OpenChainBench every 60 seconds against 7 no-key providers from us-east, eu-west and Singapore. The ranking re-sorts continuously, and the per-region leader often differs from the global one.

### What is the fastest free Base RPC?

- Page: https://openchainbench.com/answers/what-is-the-fastest-free-base-rpc
- Benchmark: https://openchainbench.com/benchmarks/base-rpc
- Answer: PublicNode is currently the fastest free Base RPC at 72 ms (eth_getBlockByNumber p50, 24h), measured by OpenChainBench every 60 seconds against 5 no-key providers from us-east, eu-west and Singapore.

### What is the fastest free Ethereum RPC?

- Page: https://openchainbench.com/answers/what-is-the-fastest-free-ethereum-rpc
- Benchmark: https://openchainbench.com/benchmarks/ethereum-rpc
- Answer: dRPC is currently the fastest free Ethereum RPC at 28 ms (eth_getBlockByNumber p50, 24h), measured by OpenChainBench every 60 seconds against 7 no-key providers from us-east, eu-west and Singapore. The ranking re-sorts continuously, and the per region leader often differs from the global one, so check the region closest to your deployment.

### What is the fastest free Hyperliquid RPC?

- Page: https://openchainbench.com/answers/what-is-the-fastest-free-hyperliquid-rpc
- Benchmark: https://openchainbench.com/benchmarks/hyperliquid-rpc
- Answer: Purroof Group is currently the fastest free Hyperliquid RPC at 125 ms (eth_getBlockByNumber p50, 24h), measured by OpenChainBench every 60 seconds against 5 no-key HyperEVM providers from us-east, eu-west and Singapore.

### What is the fastest free Optimism RPC?

- Page: https://openchainbench.com/answers/what-is-the-fastest-free-optimism-rpc
- Benchmark: https://openchainbench.com/benchmarks/optimism-rpc
- Answer: PublicNode is currently the fastest free Optimism RPC at 70 ms (eth_getBlockByNumber p50, 24h), measured by OpenChainBench every 60 seconds against 5 no-key providers from us-east, eu-west and Singapore.

### What is the fastest free Solana RPC?

- Page: https://openchainbench.com/answers/what-is-the-fastest-free-solana-rpc
- Benchmark: https://openchainbench.com/benchmarks/solana-rpc
- Answer: Solana Labs is currently the fastest free Solana RPC at 20 ms (getSlot p50, 24h), measured by OpenChainBench every 60 seconds against 5 no-key providers from us-east, eu-west and Singapore.

### What is the highest crypto staking yield right now?

- Page: https://openchainbench.com/answers/what-is-the-highest-crypto-staking-yield
- Benchmark: https://openchainbench.com/benchmarks/validator-yield
- Answer: Cosmos Hub currently pays the highest staking yield at 9.69% (median validator net yield, 24h) across the 6 chains OpenChainBench measures live; the lowest is Hyperliquid at 2.18%. Net yield means gross APR multiplied by validator uptime, after commission, with MEV included where the chain has a validator level MEV market.

### Which Base RPC pushes new blocks the fastest over WebSocket?

- Page: https://openchainbench.com/answers/which-base-rpc-pushes-new-blocks-the-fastest
- Benchmark: https://openchainbench.com/benchmarks/ws-head-latency-base
- Answer: PublicNode pushes Base newHeads the fastest at 0.3 ms lag versus the earliest provider in the cohort (p50, 24h), measured per block by OpenChainBench across 2 keyless WebSocket providers (PublicNode, dRPC) from a persistent eu-west connection.

### Which blockchain has the cheapest transaction fees in 2026?

- Page: https://openchainbench.com/answers/which-blockchain-has-cheapest-transaction-fees
- Benchmark: https://openchainbench.com/benchmarks/network-fees
- Answer: Blast currently posts the lowest median native transfer fee at $0.0000021, measured live across 20 L1 and L2 chains over the last 24 hours.

### Which cross-chain bridge has the cheapest USDC transfer fee in 2026?

- Page: https://openchainbench.com/answers/which-bridge-has-the-cheapest-usdc-fee
- Benchmark: https://openchainbench.com/benchmarks/bridge-fee
- Answer: OpenChainBench ranks six USDC routers (Mobula, Relay, LI.FI, deBridge, Across and Near Intents) on all in bridging cost (fee plus slippage plus destination gas) at $300 notional across the Solana, Base and Arbitrum corridors. The 24h p50 leader today is at openchainbench.com/benchmarks/bridge-fee; per corridor breakdown available on the same page.

### Which cross-chain bridge has the fastest quote API in 2026?

- Page: https://openchainbench.com/answers/which-bridge-has-the-fastest-quote-api
- Benchmark: https://openchainbench.com/benchmarks/bridge-quote-latency
- Answer: Mobula currently returns USDC bridge quotes the fastest at 62 ms (p50, 24h), measured live across 8 bridges on identical USDC routes by OpenChainBench.

### Which chain gained the most stablecoins this month?

- Page: https://openchainbench.com/answers/which-chain-gained-the-most-stablecoins-this-month
- Benchmark: https://openchainbench.com/benchmarks/chain-stablecoin-flow
- Answer: TRON added $1.72B of stablecoins to its float over the last 30 days, the largest net inflow among the 26 chains OpenChainBench tracks above $100M of pegged-dollar float. Net flow is the dollar change in stablecoins circulating on the chain, every issuer combined, read from DeFiLlama's per-chain series and ranked on the same 30-day window for every chain.

### Which crypto data API covers the most blockchains in 2026?

- Page: https://openchainbench.com/answers/which-crypto-data-api-covers-the-most-blockchains
- Benchmark: https://openchainbench.com/benchmarks/asset-registry-coverage
- Answer: CoinGecko currently leads the asset-registry coverage leaderboard at 468 unique mainnets, measured live every 6 hours from each provider's own registry endpoint across CoinGecko, CoinPaprika, Mobula and CoinStats. DEX-pool coverage is a different question with a separate leaderboard (GeckoTerminal, Codex, DefiLlama, DexPaprika, Sim by Dune).

### Which crypto price oracle is the most accurate in 2026?

- Page: https://openchainbench.com/answers/which-crypto-oracle-is-the-most-accurate
- Benchmark: https://openchainbench.com/benchmarks/oracle-deviation
- Answer: OpenChainBench does not name a single "most accurate" oracle because the bench is per pair, not per provider. It measures cross oracle agreement (p99 max pairwise deviation in bps, 24h) between Chainlink, Pyth, Binance and Coinbase on 10 USD pairs; the ranking by pair shows on which asset the four sources converge tightest and on which they drift. Live per pair numbers at openchainbench.com/benchmarks/oracle-deviation.

### Which crypto price API has the lowest head lag in 2026?

- Page: https://openchainbench.com/answers/which-crypto-price-api-is-the-fastest
- Benchmark: https://openchainbench.com/benchmarks/aggregator-head-lag
- Answer: Mobula (tied) currently posts the lowest head lag at 0.3 s (p50, 24h) across Mobula, Codex and GeckoTerminal on Base, BNB Chain and Solana, measured live by OpenChainBench from 3 regions.

### Which DeFi token trades at the lowest price to fees?

- Page: https://openchainbench.com/answers/which-defi-token-has-the-lowest-price-to-fees
- Benchmark: https://openchainbench.com/benchmarks/protocol-pf-ratio
- Answer: Pons has the lowest price to fees of the 65 DeFi tokens OpenChainBench tracks, at 0.202x: its market cap is that many times the fees its protocol earned over the last 30 days, annualized. Every token on the board is read against the fee-weighted median of its own category, and the rows where fees grew while the token fell are flagged, so a low multiple is never read alone.

### Which Ethereum RPC pushes new blocks the fastest over WebSocket?

- Page: https://openchainbench.com/answers/which-ethereum-rpc-pushes-new-blocks-the-fastest
- Benchmark: https://openchainbench.com/benchmarks/ws-head-latency-ethereum
- Answer: PublicNode pushes Ethereum newHeads the fastest at 0.4 ms lag versus the earliest provider in the cohort (p50, 24h), measured per block by OpenChainBench across 3 keyless WebSocket providers (PublicNode, dRPC, Tenderly, OnFinality) from a persistent eu-west connection.

### Which Ethereum gas oracle is the most accurate in 2026?

- Page: https://openchainbench.com/answers/which-gas-oracle-is-the-most-accurate
- Benchmark: https://openchainbench.com/benchmarks/gas-estimation
- Answer: Owlracle currently posts the tightest priority fee prediction at 0.925 gwei (gwei, p99 absolute gap, 24h) on Ethereum mainnet across PublicNode feeHistory, Owlracle and Etherscan, ranked on the worst 1% of blocks where gas spikes actually cost money.

### Which Hyperliquid HIP-3 deployer generates the most revenue in 2026?

- Page: https://openchainbench.com/answers/which-hyperliquid-frontend-generates-the-most-hip3-revenue
- Benchmark: https://openchainbench.com/benchmarks/hyperliquid-hip3-deployers
- Answer: trade.xyz leads 4 live HIP-3 dexes on Hyperliquid at $1.99B of notional traded over the last 24 hours. Deployer fee revenue itself is not published by the chain's public endpoints, so the ranking is by volume, the base every deployer's fee cut is taken from.

### Which Hyperliquid frontend generates the most builder revenue?

- Page: https://openchainbench.com/answers/which-hyperliquid-frontend-has-the-most-builder-revenue
- Benchmark: https://openchainbench.com/benchmarks/hyperliquid-frontends
- Answer: Trust Wallet currently leads the Hyperliquid frontends leaderboard at $20.9K in builder fee revenue on the last complete UTC day, measured by OpenChainBench from the per-builder daily fills feed Hyperliquid publishes for every attributed fill on mainnet.

### Which L1 blockchain has the fastest finality time?

- Page: https://openchainbench.com/answers/which-l1-has-the-fastest-finality
- Benchmark: https://openchainbench.com/benchmarks/l1-finality
- Answer: Gram reaches finality at 0.4 s (p50, 24h), the lowest deterministic settlement time measured across 11 L1 chains by OpenChainBench.

### Which Ethereum L2 has the fastest block time in 2026?

- Page: https://openchainbench.com/answers/which-l2-has-the-fastest-block-time
- Benchmark: https://openchainbench.com/benchmarks/l2-block-time
- Answer: Robinhood Chain currently posts the fastest L2 block time at 88 ms (p50, 24h), measured by holding a persistent `eth_subscribe("newHeads")` WebSocket on each sequencer and recording wall clock deltas between consecutive head events across 9 major Ethereum L2s.

### Which MEV protection RPC is the most consistent?

- Page: https://openchainbench.com/answers/which-mev-protection-rpc-is-the-most-consistent
- Benchmark: https://openchainbench.com/benchmarks/mev-protect-rpc
- Answer: Consistency means the p99 to p50 gap, not the median. On the live OpenChainBench MEV protection benchmark, Blink (formerly Merkle) holds the flattest tail of the cohort: its p99 sits within roughly 10 percent of its p50, while the fastest median gateway spikes an order of magnitude above its own p50 at the tail. For a wallet that fires a balance refresh, a gas estimate and a simulation on every screen, the tail is what users feel.

### Which perpetual DEX has the lowest all in fees on ETH?

- Page: https://openchainbench.com/answers/which-perp-dex-has-the-lowest-fees
- Benchmark: https://openchainbench.com/benchmarks/perp-fees
- Answer: Lighter has the lowest all in cost to open a $1000 ETH long at 0.0024% (taker fee plus half spread plus impact, 24h average) across 11 perp DEXes measured by OpenChainBench on the same order; the most expensive is dYdX v4 at 0.079%. The ranking re-sorts every 5 minutes, with $100k and $1M tiers on the bench page.

### Which perp DEX token has the lowest price to fees?

- Page: https://openchainbench.com/answers/which-perp-dex-token-has-the-lowest-price-to-fees
- Benchmark: https://openchainbench.com/benchmarks/perp-pf-ratio
- Answer: GNS trades at the lowest price to fees among 13 perp DEX tokens, at 0.993x: its market cap is that many times the fees its venue earned over the last 30 days, annualized. The table below reads every token on the same ratio next to price to sales, fully diluted valuation, float and open interest, so a low multiple can be checked against how much of the supply is still to come.

### Which prediction market API has the strictest rate limits?

- Page: https://openchainbench.com/answers/which-prediction-market-has-the-strictest-rate-limits
- Benchmark: https://openchainbench.com/benchmarks/pm-rate-limits
- Answer: Myriad documents the tightest published rate limit in the cohort at 30 requests per 10 seconds. Polymarket has no hard 429 threshold at polite rates — its Cloudflare front queues bursts and adds latency instead of returning errors. Kalshi runs a documented token bucket per access tier. Live warm-book p50 latency and daily throttle-ramp results for all five venues at openchainbench.com/benchmarks/pm-rate-limits.

### Which stablecoin has the smallest peg deviation in 2026?

- Page: https://openchainbench.com/answers/which-stablecoin-is-the-most-stable
- Benchmark: https://openchainbench.com/benchmarks/stablecoin-peg
- Answer: DAI currently holds its peg tightest at 0.00062% (median per minute worst deviation in bps, 24h) across USDC, USDT and DAI, measured live by OpenChainBench on USD quoted venues.

### Who is winning the Hyperliquid ecosystem in 2026?

- Page: https://openchainbench.com/answers/who-is-winning-hyperliquid-ecosystem
- Benchmark: https://openchainbench.com/benchmarks/hyperliquid-frontends
- Answer: Trust Wallet currently leads the Hyperliquid builder revenue leaderboard at $20.9K on the last complete UTC day, measured by OpenChainBench from Hyperliquid's public per-builder daily fills feed across all 104 tracked frontends.

---
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
- Answers index: https://openchainbench.com/answers