# OpenChainBench live state

> Auto-refreshed every 60s · last fetch 2026-11-21T07:20:32.492Z · 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: Codex posts the lowest head lag at 0.03 s (p50, 24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. Codex: 0.03 s (p99 0.37 s, success 58.8%, sample 5083)
2. Serialized: 0.04 s (p99 2.6 s, success 67.5%, sample 5834)
3. Mobula: 0.09 s (p99 0.69 s, success 67.5%, sample 5836)
4. OKX: 0.29 s (p99 1.3 s, success 67.5%, sample 5836)
5. Birdeye: 1.1 s (p99 6.7 s, success 67.5%, sample 5836)

**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 (exactly one feed wins each trade, the earliest arrival, so the shares add up to 100; 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 a raced column (Solana, BNB Chain, Robinhood Chain): the leading feed's figure is the floor, not a measured latency. Whichever feed wins a race is zero behind itself, published as 1 ms so the row renders. The gap to 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: a chain-wide `logs` subscription we hold on Base's sequencer node (`mainnet-preconf.base.org`) in every region, the first sighting of each transaction taken as the zero point. Measured 2026-11-06 against two public Base WebSockets, it saw the transaction first on 99 to 100 percent of about 1,500 trades, with a median lead of 117 and 151 ms.
- Base Denim (2026-11-05 18:00 UTC) replaced flashblocks with 200 ms canonical blocks and removed the preconfirmed state. Both former reference sources, the flashblock stream and `pendingLogs`, went silent at activation, so no Base trade was scored from 2026-11-05 18:00 UTC until the move to sealed logs on 2026-11-06. Base figures before Denim were measured against flashblock preconfirmations and are not comparable with figures after it.
- Why BNB Chain moved to the race on 2026-11-01: its reference reported a trade first on 2.99 percent of races, and a sample that beat it was discarded rather than floored. So the fastest feeds were scored only on their slowest trades, 91 percent of two feeds' samples thrown away, and the feed first on 65.53 percent of trades published a worse median than one first on 1.21 percent.
- Why Robinhood Chain moved the same day: it had no reference at all, and every provider was scored against its own block timestamp. Figures published for either chain before that date are biased upward for the fastest feeds and are not comparable with figures after it.
- The reference clock is still measured on every chain and still published as a signed series, including the trades where a feed beats it. It is not what ranks the chains that race, because a zero point that arrives after the field cannot bound it, but it is the only measurement that can see the whole field slow down at once, which a race between feeds cannot. It is what detected this.
- Why Base had two reference sources from 2026-10-29 until Denim: the flashblock endpoint is served through a CDN and carries a tail of 170 to 220 ms on its slowest decile. A reference that is late flatters every provider measured against it, and by late October one provider was arriving before our own reference on more Base races than it lost, so the zero point had stopped bounding the field.
- Adding that second Base source can only move the zero point earlier, never later, because the clock keeps the first sighting of a transaction and discards the rest. Base head-lag figures published before 2026-10-29 are therefore smaller than the same measurement would be today, by up to the size of that tail. The first-to-report shares are unaffected: that race is between providers, and the reference does not compete in it.
- Base emissions we cannot match to our reference sighting 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.
- There is no combined view across chains, and the headline is Base. Base is scored against our own node, so its figure is a latency; Solana, BNB Chain and Robinhood Chain are scored as a race, where the winner reads 1 ms because it is zero behind itself. A mean of the four moved when a feed won more races, not when it got faster. Read one chain at a time, and the raced chains through First to report.
- 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.
- Codex endpoints: Solana reads Codex's Frankfurt edge node (`fra.edge.codex.io`), Base, Robinhood Chain and BNB Chain `iad.edge.codex.io`, from all three regions. Figures for those three chains from before their move to `iad.edge.codex.io` read the standard `graph.codex.io` endpoint.
- Codex commitment levels: all four chains subscribe at Processed (on Base, until Denim, the flashblock preconfirmation the Base reference also read). Robinhood Chain and BNB Chain figures from before their move to `iad.edge.codex.io` read the default level; on Robinhood Chain it is the only one `graph.codex.io` serves.
- Codex auth: the harness authenticates with an API key Codex supplied for this bench. Earlier figures read every chain from `graph.codex.io` with a token minted from a defined.fi web session, Base at the default commitment level.

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

**Rankings (p50, 24h):**
1. Mobula: 77 ms (p99 571 ms, success 100.0%, sample 4608)
2. deBridge: 85 ms (p99 1.54 s, success 100.0%, sample 4031)
3. Relay: 162 ms (p99 494 ms, success 98.7%, sample 4544)
4. Across: 345 ms (p99 889 ms, success 100.0%, sample 2305)
5. Squid Router: 347 ms (p99 1.47 s, success 99.8%, sample 575)
6. LI.FI: 710 ms (p99 1.95 s, success 69.2%, sample 3193)
7. Socket Protocol: 1.59 s (p99 4.87 s, success 99.8%, sample 575)
8. Near Intents: 3.13 s (p99 4.97 s, success 99.6%, sample 2867)

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

**Rankings (p50, 24h):**
1. Socket Protocol: 0.012% (p99 0.017%, success 99.7%, sample 2880)
2. Squid Router: 0.020% (p99 0.023%, success 100.0%, sample 2880)
3. Near Intents: 0.053% (p99 0.056%, success 99.6%, sample 25920)
4. Across: 0.058% (p99 0.075%, success 80.0%, sample 23040)
5. Relay: 0.095% (p99 0.15%, success 99.4%, sample 46080)
6. Mobula: 0.19% (p99 0.41%, success 99.9%, sample 46080)
7. LI.FI: 0.38% (p99 1.13%, success 84.6%, sample 46080)
8. deBridge: 0.75% (p99 0.94%, success 100.0%, sample 37440)

**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.
- Origin: every figure is measured from EU-West (Paris). The us-east and sgp probes have been paused since 2026-09-10, so there is no region selector: one origin, stated once, rather than a tab offering a choice of one.
- 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.
- Also excluded, for a different reason: pump.fun's Pump Bridge is not a USDC transfer. Its only user instruction is DepositForSwap, taking a stable on Solana and delivering a token on the destination chain, so there is no USDC to USDC corridor to price and no quote endpoint to call. What it charges is read on chain in bench 268 instead.

## 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: Serialized leads field coverage at 65.9% (p50, 24h) across 4 ranked providers.

**Rankings (p50, 24h):**
1. Serialized: 65.9% (p99 73.5%, success 100.0%, sample 103816)
2. Mobula: 60.7% (p99 67.0%, success 100.0%, sample 100009)
3. Codex: 60.5% (p99 66.6%, success 100.0%, sample 103851)
4. Jupiter: 39.6% (p99 40.0%, success 100.0%, sample 49867.3)

**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 476 (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. CoinGecko: 476 (p99 476, success 100.0%, sample 476)
2. CoinPaprika: 313 (p99 313, success 100.0%, sample 313)
3. CoinStats: 152 (p99 152, success 100.0%, sample 152)
4. Mobula: 82 (p99 82, success 100.0%, sample 82)
5. Serialized: 20 (p99 20, success 100.0%, sample 20)

**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: SUI posts the lowest finality time at 0.25 s (p50, 24h) across 18 ranked chains.

**Rankings (p50, 24h):**
1. SUI: 0.25 s (p99 0.28 s, success 100.0%, sample 170139)
2. Sei: 0.28 s (p99 0.40 s, success 99.5%, sample 180711)
3. Solana: 0.39 s (p99 0.87 s, success 98.8%, sample 396252)
4. Gram: 0.40 s (p99 0.82 s, success 99.7%, sample 207476)
5. Kaia: 0.50 s (p99 1.5 s, success 98.2%, sample 84801.4)
6. Cronos: 0.58 s (p99 1.2 s, success 99.6%, sample 196761)
7. BNB: 0.76 s (p99 14 s, success 98.9%, sample 189454)
8. Internet Computer: 0.95 s (p99 1.7 s, success 100.0%, sample 168151)
9. Avalanche: 1.1 s (p99 2.0 s, success 97.8%, sample 97689.9)
10. NEAR: 1.2 s (p99 1.6 s, success 99.9%, sample 43100)
11. Algorand: 2.8 s (p99 3.0 s, success 100.0%, sample 30666.6)
12. Stellar: 5.0 s (p99 5.0 s, success 100.0%, sample 17280)
13. TRON: 57 s (p99 1.0 min, success 100.0%, sample 2880)
14. Ethereum: 15.8 min (p99 19.0 min, success 100.0%, sample 2880)
15. Robinhood Chain: 16.7 min (p99 19.7 min, success 99.3%, sample 750134)
16. Monero: 19.4 min (p99 36.9 min, success 100.0%, sample 2880)
17. Litecoin: 31.0 min (p99 51.5 min, success 100.0%, sample 493.171)
18. Bitcoin: 47.5 min (p99 166.5 min, success 100.0%, sample 161.056)

**Methodology**:
- Cadence: every 10 seconds for Ethereum, TRON and Monero; continuous WebSocket or SSE streams for BNB, Avalanche, Robinhood Chain, Solana, Sei, Cronos, Kaia, Stellar and Gram; a long poll for Algorand; 250 and 500 ms polls for the Internet Computer and SUI; 2 s for NEAR, whose figure comes from block timestamps; 30 s for Bitcoin and Litecoin.
- Ethereum: `eth_getBlockByNumber("latest")` minus `eth_getBlockByNumber("finalized")`.
- Avalanche (WS, from production): since Streaming Asynchronous Execution went live on 2026-09-22, `latest` is an accepted (Snowman-final) and executed block and `finalized` is the settled block, 5 s later by design. The figure is therefore arrival over `newHeads` minus the header's `timestampMilliseconds` (proposer clock); readings outside 0 to 60 s are dropped as skew. From 2026-09-22 to 2026-10-24 the row timed latest to finalized and published the settlement delay, about 6 s.
- BNB (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. Since 2026-11-03 a socket with no head for 20 s or no finalized advance for 30 s is reconnected: before that, the public node could stop sending heads for hours while still answering, and the row held its last value.
- Robinhood Chain (rollup, WS wall-clock): same subscription as BNB / Avalanche on `wss://robinhood-rpc.publicnode.com`. `finalized` advances by whole batches once they are finalized on the parent chain (about 10,000 blocks at about 100 ms each), so every block of a batch is timed, all of them enter the histogram, and the published series carries the batch median: the last block of a batch always has the smallest lag and would understate finality.
- Solana: WebSocket `slotSubscribe` and `rootSubscribe` on the public mainnet endpoint. T1 = first notification of slot S, T2 = first root at or above S; lag = T2 - T1 in ms. Replaced the `getBlockTime` difference on 2026-10-22, after Alpenglow made finality shorter than its one-second resolution.
- TRON: `/wallet/getnowblock` (head) minus `/walletsolidity/getnowblock` (solidity-confirmed).
- Stellar (ledger close times): Horizon `/ledgers?cursor=now&order=asc` event stream, SCP-final at every close; sample = (closed_at(N) - closed_at(N-10)) / 10, once per new ledger. Before 2026-11-03 the sample was the gap between two ledgers arriving on the stream, which measured Horizon's uneven delivery: median 4.0 s on a chain closing every 5.0 s.
- SUI: latest checkpoint from the official GraphQL service (`graphql.mainnet.sui.io`), polled every 500 ms; sample = (timestamp N − timestamp M) / (N − M) over the checkpoints committed between two polls, from the checkpoints' own millisecond commit timestamps. Before 2026-10-24 the sample was the gap between two polls that saw a new checkpoint, which only measured our 500 ms poll; that day it also moved off `sui_getLatestCheckpointSequenceNumber`, retired with JSON-RPC on the public fullnodes.
- Gram: wall-clock interval between consecutive masterchain seqnos on the tonapi.io block stream (`workchain=-1`), first sight of N+1 minus first sight of N; a transaction is final once a masterchain block includes it. When the stream is unavailable a 300 ms REST poll of the masterchain head stands in, with intervals over 2 s dropped as poll aliasing.
- 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, own-clock): Tatum public JSON-RPC `getblockcount` polled every 30 s. T1 = first poll where block N is the tip, T2 = first poll where tip − N ≥ 12 (the post-April-2026 MWEB reorg deposit floor). Same rules as Bitcoin: the startup tip is not timed, skipped heights are never timed. Until 2026-10-24 this row was the timestamp gap between the tip and the block 12 below it on litecoinspace.org, whose index had fallen about 30 minutes behind the chain.
- Monero (probabilistic): monero-rpc `get_info` minus 10 confirmations via `get_block_header_by_height`.
- NEAR (chain timestamps): every 2 s, the optimistic head from dRPC's free NEAR endpoint, plus its parent and its `last_final_block` F by hash. Sample = timestamp of the head minus timestamp of F, both nanoseconds, kept only when the parent named an older final block, so the head is the first block naming F.
- Sei and Cronos (CometBFT, from header time): `NewBlockHeader` subscription on the publicnode Tendermint WebSocket; sample = arrival minus header `time` (ns). A block is final when committed. On Sei the header time is this block's proposal; on Cronos it is BFT time, the previous height's commit, so the Cronos figure covers one whole height.
- Kaia (from block start): `newHeads` on the public Kaia endpoint WebSocket. The producer starts a block at its parent's timestamp plus one whole second (kaia work/worker.go), so for a block whose timestamp is its parent's plus one, sample = arrival minus that second. Late blocks, timestamped with a fraction newHeads does not carry, are skipped.
- Internet Computer (certified state): anonymous `read_state` for `/time` on the NNS subnet through icp-api.io, every 250 ms. When the certified time advances, sample = arrival (midpoint of the two answers' receive times) minus that time, the batch time of the block that produced the state.
- Algorand (round time): algod `wait-for-block-after` long poll on the Nodely (algonode) free endpoint; sample = arrival of round r+1 minus arrival of round r, consecutive rounds only. Block `ts` is whole seconds, so it is not used.
- 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 for the 10 s polled chains (Ethereum, TRON, Monero): `lag_seconds = headTimestamp - finalizedTimestamp`, with the block-height delta and per-chain fetch latency. Every other chain publishes milliseconds to `l1_finality_wallclock_lag_milliseconds`.
- Excluded by design: XRP (no close-time on `ledger_current`, wall-clock measurement requires WS subscribe to ledger stream, not yet implemented).
- Excluded, Somnia (checked 2026-11-03): `latest`, `safe` and `finalized` are the same block and block timestamps are whole seconds on blocks about 100 ms apart, so neither a head to finalized gap nor a timestamp to arrival time can resolve its sub-second finality.
- Excluded, Aptos (checked 2026-11-03): a fullnode serves only committed blocks, and the latest block's microsecond timestamp read 0 to 200 ms before arrival, often after our request left, so it does not mark the proposal. The Aptos Labs API also answered 429 at four requests a second.
- 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.0039% (24h avg) across 11 ranked venues.

**Rankings (p50, 24h):**
1. Lighter: 0.0039% (p99 0.016%, success 100.0%, sample 2880)
2. Extended: 0.028% (p99 0.043%, success 100.0%, sample 2880)
3. Gains: 0.040% (p99 0.040%, success 100.0%, sample 2880)
4. Polymarket: 0.045% (p99 0.15%, success 100.0%, sample 2880)
5. edgeX: 0.049% (p99 0.059%, success 100.0%, sample 2880)
6. Hyperliquid: 0.049% (p99 0.066%, success 100.0%, sample 2880)
7. Paradex: 0.050% (p99 1.30%, success 100.0%, sample 2880)
8. Aster: 0.052% (p99 0.069%, success 100.0%, sample 2880)
9. GMX: 0.060% (p99 0.060%, success 98.7%, sample 2880)
10. Ondo Perps: 0.074% (p99 0.15%, success 100.0%, sample 2880)
11. dYdX v4: 0.091% (p99 0.18%, success 100.0%, sample 2880)

**Methodology**:
- Cadence: every 5 minutes, in parallel across all venues.
- Trade simulated: a long at 10x, measured independently on ETH, BTC and SOL (the chain tabs scope the board; the unfiltered view averages the three). Headline notional $1,000 with $10k, $100k and $1M tiers rewalked on the same book.
- Hyperliquid: `POST /info {type: l2Book}` for asks + `{type: userFees, user: 0x000...000}` for taker fee + `{type: metaAndAssetCtxs}` for funding.
- dYdX v4: indexer `/orderbooks/perpetualMarket/ETH-USD` + `/perpetualMarkets` (funding) + Cosmos REST `/dydxprotocol/v4/feetiers/perpetual_fee_params` for tier-0 default fee.
- GMX v2 (Arbitrum): Subsquid GraphQL on the synthetics-arbitrum subgraph for `positionFeeFactorForNegativeImpact` (worst-case open) on the ETH/USD, BTC/USD and SOL/USD markets + gmxinfra REST for funding. Oracle priced, no orderbook: the spread term is zero.
- Lighter: `/orderBookDetails` (taker fee per market) + `/orderBookOrders` (orderbook walk).
- Gains (Gains v8 on Base): fees read directly on-chain. `eth_call pairs(N)` gives `spreadP` and `feeIndex`, then `eth_call fees(feeIndex)` gives the open fee (`totalPositionSizeFeeP`). The taker crosses one side of the book, so we charge half of `spreadP`. SOL has `spreadP` 0 on-chain (Gains prices that pair's spread dynamically), so its figure is the open fee alone. Values in 1e10 precision per Gains v8 convention. Fee tier cached 1h, pair config 6h.
- Paradex: `/markets` fee config for the 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: Serialized leads coverage rate at 74.0% (24h avg) across 5 ranked providers, measured on EOA.

**Rankings (p50, 24h):**
1. Serialized: 74.0% (p99 74.0%, success 100.0%, sample 4847.68)
2. Mobula: 55.6% (p99 55.6%, success 99.6%, sample 8638.99)
3. Blockscout: 48.0% (p99 48.0%, success 50.0%, sample 4031.39)
4. OLI: 45.6% (p99 45.6%, success 100.0%, sample 5582.93)
5. TonAPI: 35.6% (p99 35.6%, success 71.3%, sample 682.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 6 more

- Category: Blockchains
- Metric: Block time (ms)
- Page: https://openchainbench.com/benchmarks/l2-block-time
- JSON: https://openchainbench.com/api/stat/l2-block-time
- Status: live
- Headline: Robinhood Chain posts the lowest block time at 92 ms (p50, 24h) across 9 ranked chains.

**Rankings (p50, 24h):**
1. Robinhood Chain: 92 ms (p99 198 ms, success 100.0%, sample 831007)
2. Base: 194 ms (p99 494 ms, success 99.6%, sample 429765)
3. Arbitrum One: 335 ms (p99 891 ms, success 99.6%, sample 310745)
4. Scroll: 1.58 s (p99 52.74 s, success 99.1%, sample 14921.2)
5. zkSync Era: 1.73 s (p99 46.10 s, success 99.9%, sample 17658.1)
6. Mantle: 1.88 s (p99 2.98 s, success 99.6%, sample 42929.9)
7. Optimism: 1.94 s (p99 2.98 s, success 99.6%, sample 42927.9)
8. Taiko: 1.99 s (p99 3.00 s, success 99.7%, sample 43041.9)
9. Linea: 4.85 s (p99 48.50 s, success 99.8%, sample 10775.7)

**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 171 ms, success 100.0%, sample 4318.75)
2. Avalanche: 81 ms (p99 146 ms, success 100.0%, sample 4320.75)
3. PublicNode: 81 ms (p99 261 ms, success 96.1%, sample 224604)
4. Base: 104 ms (p99 138 ms, success 100.0%, sample 4319.75)
5. Tenderly: 116 ms (p99 148 ms, success 88.0%, sample 107995)
6. Arbitrum: 125 ms (p99 193 ms, success 100.0%, sample 4320.75)
7. Nodies: 134 ms (p99 211 ms, success 99.1%, sample 17274)
8. Optimism: 155 ms (p99 242 ms, success 100.0%, sample 4320.75)
9. MeowRPC: 188 ms (p99 431 ms, success 99.8%, sample 8639.5)
10. dRPC: 196 ms (p99 481 ms, success 88.9%, sample 289370)
11. NOWNodes: 206 ms (p99 635 ms, success 97.4%, sample 17272)
12. Flashbots: 339 ms (p99 538 ms, success 100.0%, sample 4320.75)

**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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency: client-side `time.Now()` delta around the round-trip, in milliseconds, exposed as the gauge `rpc_latency_milliseconds`. Percentiles come from `quantile_over_time` over that gauge across the window, so they rest on the actual observed values rather than on bucket interpolation. 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: 25 chains (23 EVM plus Solana and Polkadot). EVM majors: Ethereum, Arbitrum, Base, Optimism, Avalanche, BNB, Polygon, Linea, Scroll, Mantle. EVM long-tail: Sonic, Gnosis, Celo, Taiko, Moonbeam, Berachain, zkSync, Cronos, Fraxtal, Unichain, Soneium, Monad, MegaETH. Non-EVM: Solana (getSlot probe), Polkadot (chain_getHeader probe). Provider matrix per chain is documented in `harnesses/rpc-capabilities/cmd/script/config.go`.
- Excluded: 1RPC (delisted 2026-07-09, under 13% success even at two chains and one probe per minute), Ankr (key-gated), gateway.fm (29 req/IP budget too tight for 15s polling), LlamaRPC + BlockPI + OmniaTech (Cloudflare 521 region-blocked), Alchemy demo (rate-limited dead), NodeReal + GetBlock + Chainstack (key-gated). Blink, formerly Merkle (no public eth_getBlockByNumber) + Lava and MeowRPC outside ETH/Arb excluded. Every (provider, chain) was live-verified no-key before inclusion.

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

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

**Rankings (Gap p99 (24h), 24h):**
1. PublicNode: Gap p99 (24h) 0.990 gwei, Gap p90 0.311 gwei, Gap p50 (typical) 0.050 gwei (success 100.0%, sample 7200.5)
2. Etherscan: Gap p99 (24h) 1.28 gwei, Gap p90 0.676 gwei, Gap p50 (typical) 0.100 gwei (success 99.8%, sample 5760)
3. MetaMask: Gap p99 (24h) 2 gwei, Gap p90 1.99 gwei, Gap p50 (typical) 1.89 gwei (success 99.1%, sample 7200.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.0019% (p50, 24h) across 3 ranked providers.

**Rankings (p50, 24h):**
1. DAI: 0.0019% (p99 0.0056%, success 100.0%, sample 7199.5)
2. USDC: 0.019% (p99 0.025%, success 100.0%, sample 51840)
3. USDT: 0.14% (p99 0.24%, 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.075% (p50, 24h) across 3 ranked stablecoins.

**Rankings (p50, 24h):**
1. USDe: 0.075% (p99 0.17%, success 100.0%, sample 17280)
2. USDC: 0.12% (p99 0.22%, success 100.0%, sample 17280)
3. FDUSD: 0.38% (p99 0.41%, 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.

## Solana transaction landing services market share

- Category: Trading
- Metric: Tx count (24h) (count)
- Page: https://openchainbench.com/benchmarks/solana-tx-landing
- JSON: https://openchainbench.com/api/stat/solana-tx-landing
- Status: live
- Headline: Jito leads tx count (24h) at 5.83M (24h) across 8 ranked providers.

**Rankings (p50, 24h):**
1. Jito: 5.83M (p99 5.83M, success 82.9%, sample 5829230)
2. Helius: 2.40M (p99 2.40M, success 83.0%, sample 2399870)
3. Astralane: 74.6K (p99 74.6K, success 82.8%, sample 74635.9)
4. Nozomi: 66.3K (p99 66.3K, success 82.9%, sample 66320)
5. 0slot: 22.7K (p99 22.7K, success 82.9%, sample 22685.9)
6. bloXroute: 5,348 (p99 5,348, success 82.8%, sample 5347.86)
7. NextBlock: 2,003 (p99 2,003, success 82.9%, sample 2002.7)
8. SolanaVibeStation: 589 (p99 589, success 82.9%, sample 589.205)

**Methodology**:
- Source: `wss://api.mainnet-beta.solana.com` public WebSocket, no API key. One `logsSubscribe({mentions:[wallet]}, {commitment:confirmed})` call per known tip wallet. Server-side filtered, bandwidth scales with matched traffic, not full firehose.
- Attribution: 84 tip wallets across 8 services. Jito (8), Helius Sender (10), Nozomi (18), bloXroute (17), 0slot (21), NextBlock (8), Astralane (1), SolanaVibeStation (1). The wallet sets are disjoint, but one tx can tip two services (Helius Sender's dual path pays Helius and Jito); it then counts once for each, so shares can sum past 100% of distinct tx.
- Dedup: 50,000-entry LRU keyed by (service, signature). Reconnects can replay a few seconds of notifications, without dedup we'd double-count attribution. Memory cost ~4 MB.
- Failed tx filter: notifications with `err != null` are dropped. The bench measures LANDED tx, not submission attempts. Failed-tx flow is its own measurement and lives outside this bench.
- Reconnect: WebSocket disconnects (mainnet-beta is best-effort and kicks idle / overloaded clients) trigger exponential backoff 2s → 60s cap. Every (service, subscription) is re-established on reconnect; `solana_landing_reconnects_total` surfaces stability over the day.
- Blind spots. Syncro Sender (P2P.org) uses per-customer tip wallets not publicly documented, invisible. Slipstream is a router that routes through underlying senders, so its tx are attributed to the underlying service (Jito/Nozomi/etc.). Direct-RPC tx that pay only a priority fee (no tip to a landing service) are not measured, they constitute the majority of Solana volume but they're not the subject of this bench.
- Excluded by design: time-to-land, success rate per service, geographic latency. Those would require sending controlled tx (active probing) which costs SOL and risks services fingerprinting our probes. This bench is purely observational.

## 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 82.5% (7d avg) across 2 ranked protocols.

**Rankings (p50, 7d):**
1. Hyperliquid: 82.5% (p99 82.5%, success 100.0%, sample 17530700)
2. Sky (Maker): 47.5% (p99 47.5%, success 100.0%, sample 1592070)

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

**Rankings (p50, 24h):**
1. XRP/USD: 0.13% (p99 0.25%, success 100.0%, sample 5760)
2. LINK/USD: 0.14% (p99 0.27%, success 100.0%, sample 8640)
3. POL/USD: 0.14% (p99 0.42%, success 100.0%, sample 8640)
4. AVAX/USD: 0.14% (p99 0.29%, success 100.0%, sample 8640)
5. BNB/USD: 0.14% (p99 0.28%, success 100.0%, sample 8640)
6. SOL/USD: 0.14% (p99 0.26%, success 100.0%, sample 8640)
7. BTC/USD: 0.14% (p99 0.24%, success 100.0%, sample 8640)
8. DOGE/USD: 0.14% (p99 0.29%, success 100.0%, sample 5760)
9. ETH/USD: 0.14% (p99 0.25%, success 100.0%, sample 8640)
10. ADA/USD: 0.14% (p99 0.29%, success 100.0%, sample 5760)

**Methodology**:
- Sources. Chainlink AggregatorV3 via `eth_call(latestRoundData())` on Ethereum mainnet (no API key, public RPC with fallback), Binance REST `/api/v3/ticker/price` on USDT-quoted symbols (treated as ≈ USD), Coinbase REST `/products/<P>/ticker` on USD-quoted products. All three are free, no-auth, public endpoints. Pyth Hermes was a fourth until its price paths began returning 401 without a key.
- Pairs (10). BTC, ETH, SOL, BNB, AVAX, LINK and POL are tracked on all 4 sources. XRP, ADA, DOGE are tracked on 2 sources (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). 3 sources × 10 pairs × 2/minute = 60 requests/minute total, comfortably under every free-tier ceiling (Binance 1200/min, Coinbase 10/s public, 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 net APR by proof-of-stake chain

- 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 18.8% (24h avg) across 15 ranked chains.

**Rankings (p50, 24h):**
1. Cosmos Hub: 18.8% (p99 18.8%, success 100.0%, sample 180)
2. Gram: 12.0% (p99 13.1%, success 100.0%, sample 6)
3. Internet Computer: 9.82% (p99 9.82%, success 100.0%, sample 1)
4. NEAR: 5.12% (p99 5.50%, success 96.5%, sample 200)
5. Solana: 4.84% (p99 5.35%, success 99.8%, sample 200)
6. Algorand: 4.55% (p99 4.55%, success 100.0%, sample 1)
7. Avalanche: 4.10% (p99 6.09%, success 99.2%, sample 100)
8. Kaia: 3.93% (p99 3.93%, success 100.0%, sample 9)
9. Sei: 3.84% (p99 3.84%, success 100.0%, sample 40)
10. Cronos: 3.56% (p99 3.56%, success 100.0%, sample 100)
11. Ethereum: 2.50% (p99 2.50%, success 100.0%, sample 1)
12. Aptos: 2.39% (p99 2.55%, success 99.7%, sample 49)
13. Hyperliquid: 2.17% (p99 2.24%, success 77.1%, sample 35)
14. Cardano: 1.98% (p99 2.11%, success 100.0%, sample 50)
15. Sui: 1.22% (p99 1.32%, success 100.0%, sample 125)

**Methodology**:
- Definition. net_yield_bps = gross APR × (1 − commission) × uptime where the chain exposes uptime, in basis points (1% = 100 bps), simple APR. Gross is measured where the chain records realized rewards and read from protocol parameters where it does not. The chain headline is ocb_chain_median_net_yield_bps, the median over the tracked cohort, computed in the harness every scrape.
- Cadence and cohort hygiene. One scrape per chain every 5 minutes. A validator that leaves a cohort has its series deleted on the next scrape, so p90, p99 and the mean never read a departed validator. Prices come from one batched CoinGecko call for the USD stake column only; the yield never depends on a price.
- Solana. Stakewiz `api.stakewiz.com/validators`: total_apy, a 30 epoch trailing figure that already folds in Jito MEV tips and is net of commission, times uptime. Top 200 by activated stake. Commission is read in basis points (Stakewiz switched units when Solana moved commission to bps).
- Hyperliquid. `POST api.hyperliquid.xyz/info {type: validatorSummaries}`: predictedApr.day times stats[day].uptimeFraction, all active validators, jailed ones at 0. No MEV layer at validator level.
- Ethereum. ultrasound.money live total effective balance into the consensus spec reward formula, APR = 64 × epochs per year / sqrt(total gwei): one network-average row for a 32 ETH solo validator. Execution tips and MEV excluded. Not a liquid staking APY.
- Cardano. Koios epoch_info: total rewards paid for the latest computed epoch × 73 epochs / active stake, the measured network return after reserve depletion, treasury cut, pledge influence and saturation. Per pool, net = gross × (1 − margin) for the top 50 registered pools by active stake; the 340 ADA fixed fee is not subtracted.
- Sui. Sui GraphQL (public JSON-RPC was retired): each validator's staking pool exchange rate (SUI per pool token) now versus 30 epochs ago, annualized over the elapsed time. Commission is paid inside the pool, so the figure is already the delegator's net.
- Avalanche. P-Chain platform.getCurrentValidators: gross = potentialReward / stake × year / staking period, the protocol reward for that validator's own duration and start supply. Net = gross × uptime × (1 − delegation fee). Top 100 by stake; validators with a 100% delegation fee count at 0 for delegators.
- Aptos. Fullnode REST: StakingRewardsConfig.rewards_rate (2.60% a year after the April 2026 cut) per 2 hour epoch. Cohort: active validators that are delegation pools. Net = gross × this epoch's successful / total proposals × (1 − operator commission).
- NEAR. FastNEAR RPC: total supply × max inflation (2.5%) × (1 − treasury share) / total validator stake. Net = gross × the protocol online factor (0 under 90% online, full at 99%) × (1 − pool fee). Top 200 validators by stake that are staking pool contracts. Realized previous epoch checked at 5.47% gross against 5.52% formula on 2026-11-03.
- Kaia. Endpoint node RPC: kaia_getRewards per-block stakers share × blocks per year (measured over 10 000 blocks) / total staked KAIA from kaia_getStakingInfo. Cohort: council nodes with a public delegation contract, net = gross × (1 − its commissionRate).
- Algorand. algod (Nodely): blocks per year × mean proposer payout of incentive-eligible blocks / online stake. One row: the yield of running your own participating node with 30k to 70M ALGO, opted in. No delegation, no commission; holding ALGO without a node earns nothing.
- ICP. ICP dashboard API (NNS governance metrics): 365.25 × daily voting reward pool × 3 / total deciding voting power. One row: a new neuron at the 2 year maximum dissolve delay (bonus 3), no age bonus, voting on everything. Shorter delays earn far less (2 weeks: about a third). Rewards accrue as maturity, subject to maturity modulation at disbursement.
- Gram (TON). TonAPI staking pools: the realized nominator APY of each verified, funded, non-liquid pool (TON Whales and Tonkeeper queues), already net of the pool fee, de-compounded to APR over the 131 072 second validation cycle. Liquid staking (Tonstakers) excluded like Lido on Ethereum.
- Cosmos Hub, Sei, Cronos. LCD REST: annual issuance × (1 − community tax) / bonded tokens, net = gross × (1 − commission), jailed at 0. Hub and Cronos issuance = annual_provisions × real blocks per year / the mint blocks_per_year parameter; Sei issuance = its token release schedule for the current year. Cronos here is the Cronos POS chain where CRO is staked.
- Not ranked. Stellar has no staking. Somnia rewards are half of gas fees, paid by a protocol call at each 5 minute epoch that emits no event, with eth_getLogs capped at 1000 blocks; the fee inflow cannot be isolated from stakes and claims keylessly. Third parties quote Somnia's own dashboard, between 0.06% and 0.25%.

## 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 $26.8K (24h) across 109 ranked providers.

**Rankings (Revenue, 24h):**
1. Trust Wallet: Revenue $26.8K, Volume $26.83M, $ / user $26.46 (success 100.0%, sample 8277)
2. Phantom: Revenue $25.7K, Volume $45.87M, $ / user $6.86 (success 100.0%, sample 29003)
3. FOMO: Revenue $25.6K, Volume $55.28M, $ / user $11.23 (success 100.0%, sample 21433)
4. MetaMask: Revenue $21.6K, Volume $21.59M, $ / user $20.35 (success 100.0%, sample 7624)
5. Rabby: Revenue $12.9K, Volume $33.46M, $ / user $18.75 (success 100.0%, sample 10555)
6. Invo: Revenue $7,487.45, Volume $21.39M, $ / user $1.70 (success 100.0%, sample 33747)
7. OneKey: Revenue $5,197.51, Volume $6.50M, $ / user $44.42 (success 100.0%, sample 1582)
8. Hyperdash: Revenue $4,447.19, Volume $23.10M, $ / user $18.76 (success 100.0%, sample 8729)
9. Bitget Wallet: Revenue $3,746.01, Volume $8.70M, $ / user $14.98 (success 100.0%, sample 3181)
10. 0x7cc0…e781: Revenue $3,315.36, Volume $9.39M, $ / user $1.05 (success 100.0%, sample 16192)
11. 0xf85a…5688: Revenue $3,022.75, Volume $4.32M, $ / user $55.98 (success 100.0%, sample 1578)
12. Liquid Perps: Revenue $2,447.08, Volume $6.48M, $ / user $4.75 (success 100.0%, sample 5226)
13. Axiom: Revenue $1,384.84, Volume $5.46M, $ / user $7.78 (success 100.0%, sample 1862)
14. Insilico: Revenue $1,363.89, Volume $13.64M, $ / user $10.91 (success 100.0%, sample 5947)
15. Moonbot: Revenue $1,283.69, Volume $8.63M, $ / user $14.76 (success 100.0%, sample 6509)
16. Metascalp: Revenue $1,182.8, Volume $8.85M, $ / user $4.89 (success 100.0%, sample 38654)
17. based.app: Revenue $993.78, Volume $1.83M, $ / user $8.01 (success 100.0%, sample 1438)
18. BullpenFi: Revenue $948.65, Volume $3.23M, $ / user $55.80 (success 100.0%, sample 344)
19. Onchain.cc: Revenue $837.20, Volume $1.14M, $ / user $2.70 (success 100.0%, sample 2091)
20. 0x42f3…f992: Revenue $773.30, Volume $4.42M, $ / user $8.99 (success 100.0%, sample 2681)
21. Wallet V: Revenue $566.84, Volume $2.83M, $ / user $9.77 (success 100.0%, sample 1236)
22. Legend Trade: Revenue $409.94, Volume $734.7K, $ / user $0.8648 (success 100.0%, sample 1887)
23. MetaMask (alt): Revenue $402.36, Volume $402.4K, $ / user $4.91 (success 100.0%, sample 341)
24. Dexly Trade: Revenue $336.63, Volume $684.9K, $ / user $9.10 (success 100.0%, sample 438)
25. Splash: Revenue $249.59, Volume $2.48M, $ / user $62.40 (success 100.0%, sample 38)
26. 0x446f…d6c6: Revenue $230.45, Volume $768.2K, $ / user $76.82 (success 100.0%, sample 335)
27. Dreamcash: Revenue $196.75, Volume $447.4K, $ / user $2.70 (success 100.0%, sample 454)
28. Dextrabot: Revenue $187.47, Volume $342.3K, $ / user $7.21 (success 100.0%, sample 799)
29. 0x9f83…31d9: Revenue $177.99, Volume $444.8K, $ / user $3.42 (success 100.0%, sample 298)
30. STRYX: Revenue $168.42, Volume $786.5K, $ / user $18.71 (success 100.0%, sample 382)
31. Wunder: Revenue $156.79, Volume $448.6K, $ / user $1.15 (success 100.0%, sample 1405)
32. Rainbow: Revenue $136.81, Volume $273.6K, $ / user $3.34 (success 100.0%, sample 236)
33. XBIT: Revenue $132.08, Volume $660.4K, $ / user $18.87 (success 100.0%, sample 182)
34. Mass.money: Revenue $128.94, Volume $229.5K, $ / user $3.79 (success 100.0%, sample 247)
35. 0xdbc2…97a6: Revenue $112.64, Volume $113.9K, $ / user $2.17 (success 100.0%, sample 178)
36. Cwallet: Revenue $110.09, Volume $443.4K, $ / user $10.01 (success 100.0%, sample 97)
37. VergeX: Revenue $108.55, Volume $271.0K, $ / user $1.57 (success 100.0%, sample 7284)
38. 0xc95d…1aca: Revenue $104.61, Volume $2.21M, $ / user $52.31 (success 100.0%, sample 1425)
39. HyperX: Revenue $91.09, Volume $176.2K, $ / user $3.14 (success 100.0%, sample 1238)
40. Tread.fi: Revenue $66.49, Volume $591.1K, $ / user $1.55 (success 100.0%, sample 14601)
41. UnityWallet: Revenue $49.45, Volume $49.6K, $ / user $8.24 (success 100.0%, sample 46)
42. Markets Mobile: Revenue $44.08, Volume $692.4K, $ / user $1.63 (success 100.0%, sample 385)
43. Infinex: Revenue $43.39, Volume $87.3K, $ / user $2.07 (success 100.0%, sample 130)
44. pvp.trade: Revenue $40.90, Volume $113.9K, $ / user $4.54 (success 100.0%, sample 109)
45. ApexLiquid: Revenue $38.07, Volume $76.4K, $ / user $0.8853 (success 100.0%, sample 1251)
46. Owly.fi: Revenue $35.99, Volume $65.4K, $ / user $2.57 (success 100.0%, sample 643)
47. Proliquid: Revenue $35.72, Volume $184.2K, $ / user $7.14 (success 100.0%, sample 33)
48. Tradoor: Revenue $35.49, Volume $60.1K, $ / user $2.73 (success 100.0%, sample 2408)
49. cro.trade: Revenue $31.51, Volume $52.5K, $ / user $2.86 (success 100.0%, sample 70)
50. Okto: Revenue $22.50, Volume $125.0K, $ / user $4.50 (success 100.0%, sample 18)
51. Sushi: Revenue $19.23, Volume $32.5K, $ / user $9.62 (success 100.0%, sample 11)
52. CCXT: Revenue $14.76, Volume $156.1K, $ / user $0.3515 (success 100.0%, sample 952)
53. CoinPilot: Revenue $12.13, Volume $24.3K, $ / user $0.3914 (success 100.0%, sample 406)
54. VOOI: Revenue $11.27, Volume $82.7K, $ / user $0.5365 (success 100.0%, sample 310)
55. Moontrader: Revenue $7.43, Volume $46.1K, $ / user $1.49 (success 100.0%, sample 138)
56. Dexari: Revenue $6.80, Volume $7,803.71, $ / user $1.36 (success 100.0%, sample 9)
57. goodcryptoX: Revenue $6.50, Volume $21.7K, $ / user $0.6504 (success 100.0%, sample 247)
58. defi.app: Revenue $6.21, Volume $12.4K, $ / user $0.5645 (success 100.0%, sample 26)
59. Nansen: Revenue $3.35, Volume $12.0K, $ / user $0.1523 (success 100.0%, sample 67)
60. Senpi: Revenue $2.41, Volume $225.7K, $ / user $0.0277 (success 100.0%, sample 600)
61. Arena: Revenue $1.97, Volume $2,081.94, $ / user $0.4934 (success 100.0%, sample 9)
62. MinaraAI: Revenue $1.76, Volume $4,396.61, $ / user $1.76 (success 100.0%, sample 1)
63. Perpex: Revenue $1.37, Volume $1,367.68, $ / user $0.6838 (success 100.0%, sample 35)
64. MOJO: Revenue $1.20, Volume $2,391.38, $ / user $0.1495 (success 100.0%, sample 20)
65. Gem Wallet: Revenue $1.08, Volume $2,395.04, $ / user $0.5389 (success 100.0%, sample 6)
66. 0x53a1…fcd1: Revenue $0.6458, Volume $645.76, $ / user $0.3229 (success 100.0%, sample 2)
67. DeFi Saver: Revenue $0.4029, Volume $1,611.72, $ / user $0.4029 (success 100.0%, sample 2)
68. Origami Tech: Revenue $0.2828, Volume $2,828.07, $ / user $0.0943 (success 100.0%, sample 25)
69. Miracle: Revenue $0.2013, Volume $1,342.17, $ / user $0.2013 (success 100.0%, sample 1)
70. MarsGO: Revenue $0.1553, Volume $200.73, $ / user $0.0777 (success 100.0%, sample 3)
71. KuCoin Web3: Revenue $0.1313, Volume $262.59, $ / user $0.1313 (success 100.0%, sample 1)
72. Hyprearn: Revenue $0.0956, Volume $298.16, $ / user $0.0478 (success 100.0%, sample 4)
73. Nova: Revenue $0.0784, Volume $224.07, $ / user $0.0784 (success 100.0%, sample 14)
74. SuperCEXy: Revenue $0.0246, Volume $245.54, $ / user $0.0246 (success 100.0%, sample 2)
75. PerpsWLD: Revenue $0.00991, Volume $9.91, $ / user $0.00991 (success 100.0%, sample 1)
76. True Markets: Revenue $0.00988, Volume $49.42, $ / user $0.00494 (success 100.0%, sample 2)
77. Blink: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
78. Perpmate: 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. GTR Trade: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
82. Katoshi: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
83. Pear: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
84. Ranger Finance: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
85. SuperX: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
86. Supurr: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
87. Unigox: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
88. UXUY: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
89. Grider: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
90. Liminal: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
91. Lit Trade: Revenue $0, Volume $559.13, $ / user $0 (success 100.0%, sample 28)
92. Lootbase: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
93. Superstack: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
94. xTrade Protocol: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
95. Taco Trade: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
96. Silhouette: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
97. FlowBot: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
98. Nautilus Trader: Revenue $0, Volume $548.4K, $ / user $0 (success 100.0%, sample 1598)
99. 0xb290…c34a: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
100. Kinto: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
101. HyperSignals: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
102. VibeLiquid: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
103. Slash: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
104. SHAX: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
105. Aura: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
106. TopDog: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
107. Pocket Protector: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
108. Cipher: Revenue $0, Volume $0, $ / user $0 (success 100.0%, sample 0)
109. Afterbell: 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.
- Node substitution. Hyperliquid's public export cuts most days off around 12:10 UTC, so where our own Hyperliquid node holds a day end to end that day replaces the export's copy of it outright, never an average of the two. A day the node cannot replay may be reconstructed from the export's morning plus an afternoon rebuilt per wallet from the info API; reconstructions are counted and published apart from measured days, because close is not measured.
- Reproducibility. Harness source is open in the OCB harness tree. Anyone can run it against the same public feed with the same registry, which reproduces every number for the days that rest on the export. The days our node measured cannot be reproduced from the public feed alone, and the coverage gauges say which days those are.
- 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: Stellar posts the lowest native transfer fee USD at $0.0000013 (p50, 24h) across 27 ranked chains.

**Rankings (p50, 24h):**
1. Stellar: $0.0000013 (p99 $0.0000013, success 100.0%, sample 20160)
2. Optimism: $0.0000126 (p99 $0.000704, success 100.0%, sample 20160)
3. Somnia: $0.0000154 (p99 $0.0000245, success 100.0%, sample 20160)
4. Kaia: $0.0000159 (p99 $0.0000516, success 100.0%, sample 20160)
5. Aptos: $0.0000233 (p99 $0.0000388, success 100.0%, sample 20160)
6. Sei: $0.0000368 (p99 $0.0000594, success 100.0%, sample 20160)
7. Algorand: $0.0000733 (p99 $0.0000768, success 100.0%, sample 20160)
8. NEAR: $0.000127 (p99 $0.000136, success 100.0%, sample 20160)
9. Internet Computer: $0.000202 (p99 $0.000217, success 100.0%, sample 20160)
10. Base: $0.000234 (p99 $0.0145, success 100.0%, sample 20160)
11. Taiko: $0.000299 (p99 $0.000323, success 100.0%, sample 20160)
12. Cronos: $0.000313 (p99 $0.000416, success 100.0%, sample 20160)
13. Solana: $0.000345 (p99 $0.00362, success 99.8%, sample 20160)
14. Mantle: $0.000399 (p99 $0.00656, success 100.0%, sample 20160)
15. BNB Chain: $0.000579 (p99 $0.00305, success 100.0%, sample 20160)
16. Sui: $0.000710 (p99 $0.000760, success 100.0%, sample 20160)
17. Robinhood Chain: $0.000718 (p99 $0.000787, success 100.0%, sample 20160)
18. Arbitrum One: $0.000755 (p99 $0.00274, success 100.0%, sample 20160)
19. Avalanche: $0.00115 (p99 $0.0157, success 100.0%, sample 20160)
20. zkSync Era: $0.00154 (p99 $0.00167, success 100.0%, sample 20160)
21. Linea: $0.00217 (p99 $0.0375, success 100.0%, sample 20160)
22. Scroll: $0.00255 (p99 $0.0792, success 100.0%, sample 20160)
23. Gram: $0.00493 (p99 $0.00514, success 100.0%, sample 20160)
24. Ethereum: $0.0138 (p99 $0.4758, success 100.0%, sample 20160)
25. Cardano: $0.0238 (p99 $0.0250, success 100.0%, sample 20160)
26. Monero: $0.0546 (p99 $0.2330, success 100.0%, sample 20160)
27. TRON: $0.0803 (p99 $0.0808, success 100.0%, sample 20160)

**Methodology**:
- Refresh cadence. 30 seconds. One process samples every chain in the table in parallel goroutines.
- Ethereum, BNB Chain, Avalanche, Sei, Cronos, Kaia and Somnia on the L1 tab. eth_feeHistory over the last 4 blocks at percentiles 25, 50 and 90, median across the 4 blocks per percentile. Cost = (base_fee + reward_percentile) * 21000 gas in the chain's own gas token, mapped to slow, standard and fast.
- Arbitrum, Optimism, Base, 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, 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 the 1000 unit minimum computation bucket, plus 988000 MIST of storage for the new coin object of a SplitCoins + TransferObjects send, net of the gas coin rebate. 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.
- Algorand. algod /v2/transactions/params: max(min-fee, fee per byte times 250 bytes) for a signed payment. min-fee is 1000 microAlgo and the per byte fee is zero outside congestion. Single tier.
- Aptos. /v1/estimate_gas_price (deprioritized, standard, prioritized octas per gas unit) times 63 gas units, the median measured for an aptos_account::transfer of APT to an existing account.
- NEAR. gas_price (yoctoNEAR per gas) times the gas a transfer between existing named accounts burns: action receipt creation plus transfer action, send_not_sir plus execution, read from EXPERIMENTAL_protocol_config. Single tier.
- Internet Computer. The ICP ledger transfer fee from the ICP Rosetta /construction/metadata suggested_fee (10000 e8s, 0.0001 ICP). Cycles are paid by canister developers and are not part of what the sender pays. Single tier.
- USD prices. api.mobula.io/api/1/market/multi-data polled every 30 seconds for every native token, by asset slug or by Mobula asset id for tokens that were renamed (Gram) or added later.
- 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: ParaSwap posts the lowest quote latency at 215 ms (p50, 24h) across 8 ranked providers.

**Rankings (p50, 24h):**
1. ParaSwap: 215 ms (p99 943 ms, success 100.0%, sample 4319.75)
2. KyberSwap: 219 ms (p99 945 ms, success 99.9%, sample 4315.75)
3. Nordstern: 270 ms (p99 993 ms, success 99.2%, sample 3574.62)
4. Uniswap: 435 ms (p99 1.13 s, success 100.0%, sample 3599.62)
5. Mobula: 549 ms (p99 1.93 s, success 99.9%, sample 3595.62)
6. LI.FI: 703 ms (p99 3.55 s, success 62.0%, sample 2677.46)
7. Bebop: 796 ms (p99 1.60 s, success 100.0%, sample 3598.62)
8. CoW Protocol: 1.79 s (p99 4.10 s, success 100.0%, sample 2879.5)

**Methodology**:
- Six fixed pairs across five 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 6 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. Uniswap uses 0x0000... and Bebop substitutes the wrapped equivalent on the sell side. The adapter normalises per provider.
- Provider auth: three providers need a key (Mobula in an Authorization header, Route as a Bearer token, Uniswap in a vendor header), and KyberSwap, Bebop, LI.FI, CoW, ParaSwap, Nordstern and OpenOcean answer a bare request. The key is not what buys the low end of this table.

## Cheapest blockchain to deploy a token, live USD cost per L1 chain

- 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: Kaia posts the lowest token deployment cost USD at $0.000422 (p50, 24h) across 19 ranked chains.

**Rankings (p50, 24h):**
1. Kaia: $0.000422 (p99 $0.000444, success 100.0%, sample 20160)
2. Osmosis: $0.000973 (p99 $0.00106, success 100.0%, sample 20160)
3. Sei: $0.00147 (p99 $0.00158, success 100.0%, sample 20160)
4. Gram: $0.00493 (p99 $0.00514, success 100.0%, sample 20160)
5. Algorand: $0.00740 (p99 $0.00776, success 100.0%, sample 20160)
6. Cronos: $0.00827 (p99 $0.00860, success 100.0%, sample 20160)
7. Somnia: $0.00831 (p99 $0.0129, success 100.0%, sample 20160)
8. Polygon PoS: $0.0121 (p99 $0.0129, success 100.0%, sample 20160)
9. BNB Chain: $0.0150 (p99 $0.0160, success 100.0%, sample 20160)
10. Avalanche: $0.0274 (p99 $0.0974, success 100.0%, sample 20160)
11. Aptos: $0.0555 (p99 $0.0616, success 100.0%, sample 20160)
12. Cardano: $0.1673 (p99 $0.1762, success 100.0%, sample 20160)
13. Ethereum: $0.2893 (p99 $11.19, success 100.0%, sample 20160)
14. Stellar: $0.3187 (p99 $0.3365, success 100.0%, sample 20160)
15. Sui: $0.3264 (p99 $0.3493, success 100.0%, sample 20160)
16. Solana: $0.4589 (p99 $0.4840, success 100.0%, sample 20160)
17. Injective: $0.6259 (p99 $0.6692, success 100.0%, sample 20140)
18. Internet Computer: $0.6753 (p99 $0.6881, success 100.0%, sample 20160)
19. NEAR: $6.40 (p99 $6.85, success 100.0%, sample 20160)

**Methodology**:
- Refresh cadence. 5 minutes. One process samples every chain in parallel goroutines and emits Prometheus gauges. A chain whose sampler or price has failed for 30 minutes stops publishing a USD cost, so a dead upstream shows as down instead of a stale number.
- EVM chains (Ethereum, BNB Chain, Avalanche, Polygon PoS, Sei, Cronos, Kaia, Somnia). eth_estimateGas on the OpenZeppelin Contracts Wizard default ERC20 (OpenZeppelin 5.0.2, solc 0.8.24, 200 runs, evmVersion paris, 3096 bytes of init code) times eth_gasPrice. Same bytes on every chain; source and compile script are in the harness.
- Solana SPL. getMinimumBalanceForRentExemption for the 82 byte mint, the 165 byte Associated Token Account and the 679 byte Metaplex metadata account, plus 5000 lamports for the signature. Rent is locked, refundable if the accounts are closed.
- Sui. epoch.referenceGasPrice from the Sui GraphQL service times a pinned 5 million gas unit budget for a coin module publish, net of storage rebate. Aptos. /v1/estimate_gas_price gas_estimate times a pinned 150,000 gas unit budget for a fungible asset publish.
- Osmosis and Injective TokenFactory. LCD tokenfactory params.denom_creation_fee (empty on Osmosis, 0.1 INJ on Injective) plus MsgCreateDenom gas (80,000 baseline plus denom_creation_gas_consume) at a pinned typical gas price per chain.
- Cardano. Koios epoch_params.coins_per_utxo_size times (160 byte overhead plus a 70 byte single asset bundle), plus a 180,000 lovelace mint transaction fee.
- Stellar. Latest ledger base_reserve_in_stroops and base_fee_in_stroops: 5 base reserves (2 per new account for the issuer and the distribution account, 1 for the trustline) plus 2 base fees. Reserves are locked, refundable on account closure.
- Algorand ASA. algod /v2/transactions/params: max(min-fee, fee per byte times 250 bytes) for the asset config transaction, plus the 0.1 ALGO minimum balance raise per asset, refundable when the asset is destroyed.
- Gram (TON) jetton. The standard minter.ton.org flow (wallet, minter with its StateInit and mint, jetton wallet deploy, notification, excess) priced with live basechain config params 21 and 25 from tonapi. Gas and message sizes are pinned from a real mainnet deploy, which the model reproduces to within 28 nanoton. Only fees are counted; the TON attached to the deploy stays in the contracts or returns as excess.
- NEAR. The tkn.near factory's own get_required_deposit quote for a token with this bench's name and symbol, the storage stake of the new token account at the live storage price, plus 106 Tgas of create_token gas at the live gas_price. The stake stays locked in the token account.
- Internet Computer. 500 billion cycles to create the ledger canister on a 13 node subnet, converted to ICP at the live ICP/XDR rate published from the cycles minting canister (1 trillion cycles is 1 XDR). The ledger's running cycle reserve is not counted.
- USD prices. Mobula market multi-data by ticker, refreshed every 5 minutes and treated as missing after an hour. Gram is priced with GRAM, since Mobula's TON ticker resolves to a different asset.
- Not tracked. L2s and rollups, whose deploy also pays an L1 data fee that eth_estimateGas does not report uniformly across stacks.

## 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 $6.38B (24h) across 4 ranked providers.

**Rankings (Volume, 24h):**
1. trade.xyz: Volume $6.38B, Open interest $4.18B, Markets traded 123 (success 100.0%, sample 123)
2. EntropyIO: Volume $139.05M, Open interest $114.40M, Markets traded 18 (success 100.0%, sample 18)
3. Paragon: Volume $9.95M, Open interest $12.71M, Markets traded 33 (success 100.0%, sample 33)
4. Markets by Kinetiq (mkts): Volume $700.1K, Open interest $181.1K, Markets traded 1 (success 100.0%, sample 1)

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

**Rankings (ETH hold 24h, 24h):**
1. Hyperliquid: ETH hold 24h -2.94 bps, BTC -0.06 bps, SOL -1.55 bps, Annualized -10.7% (success 100.0%, sample 2880)
2. OKX: ETH hold 24h -2.64 bps, BTC -0.71 bps, SOL -2.66 bps, Annualized -9.64% (success 100.0%, sample 2880)
3. Lighter: ETH hold 24h -2.52 bps, BTC 2.16 bps, SOL -3.41 bps, Annualized -9.21% (success 100.0%, sample 2880)
4. Binance: ETH hold 24h -2.43 bps, BTC -0.59 bps, SOL -3.19 bps, Annualized -8.85% (success 100.0%, sample 2880)
5. Kalshi: ETH hold 24h -2.35 bps, BTC 0.48 bps, SOL 0 bps, Annualized -8.59% (success 100.0%, sample 2880)
6. Bybit: ETH hold 24h -2.17 bps, BTC -0.55 bps, SOL -3.09 bps, Annualized -7.91% (success 100.0%, sample 2880)
7. Paradex: ETH hold 24h -1.80 bps, BTC 0.66 bps, SOL -1.77 bps, Annualized -6.56% (success 100.0%, sample 2880)
8. Lighter RH: ETH hold 24h -1.58 bps, BTC 0.62 bps, SOL -0.63 bps, Annualized -5.77% (success 100.0%, sample 2880)
9. Aster: ETH hold 24h -1.25 bps, BTC 0.51 bps, SOL -3.14 bps, Annualized -4.56% (success 100.0%, sample 2880)
10. Pacifica: ETH hold 24h -0.81 bps, BTC -0.50 bps, SOL -1.33 bps, Annualized -2.96% (success 100.0%, sample 2880)
11. Polymarket: ETH hold 24h 1.15 bps, BTC 3.00 bps, SOL -2.14 bps, Annualized 4.20% (success 100.0%, sample 2880)
12. Extended: ETH hold 24h 2.33 bps, BTC 3.11 bps, SOL 0.24 bps, Annualized 8.50% (success 100.0%, sample 2880)
13. ApeX Omni: ETH hold 24h 2.43 bps, BTC 2.70 bps, SOL 2.77 bps, Annualized 8.85% (success 100.0%, sample 2880)
14. edgeX: ETH hold 24h 2.96 bps, BTC 3.00 bps, SOL 3.00 bps, Annualized 10.8% (success 100.0%, sample 2874)
15. Ondo Perps: ETH hold 24h 3.00 bps, BTC 2.99 bps, SOL 2.90 bps, Annualized 10.9% (success 100.0%, sample 2880)
16. StandX: ETH hold 24h 3.00 bps, BTC 3.00 bps, SOL 2.99 bps, Annualized 10.9% (success 100.0%, sample 2880)
17. Vest: ETH hold 24h 4.55 bps, BTC 2.06 bps, SOL -7.57 bps, Annualized 16.6% (success 100.0%, sample 2880)
18. dYdX v4: ETH hold 24h 4.85 bps, BTC 2.75 bps, SOL 0.77 bps, Annualized 17.7% (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 90 ms (p50, 24h) across 6 ranked venues.

**Rankings (Warm book p50, 24h):**
1. Polymarket: Warm book p50 90 ms, p99 248 ms (success 100.0%, sample 51828)
2. PredictIt: Warm book p50 101 ms, p99 397 ms (success 66.7%, sample 17280)
3. Kalshi: Warm book p50 124 ms, p99 566 ms (success 100.0%, sample 51840)
4. Limitless: Warm book p50 289 ms, p99 590 ms (success 100.0%, sample 51840)
5. Manifold: Warm book p50 375 ms, p99 9.91 s (success 100.0%, sample 37028.9)
6. Myriad: Warm book p50 516 ms, p99 4.23 s (success 99.7%, sample 51737)

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

**Rankings (Warm price p50, 24h):**
1. Polymarket: Warm price p50 90 ms, p99 248 ms (success 100.0%, sample 51816.3)
2. PredictIt: Warm price p50 101 ms, p99 397 ms (success 66.7%, sample 17280)
3. Kalshi: Warm price p50 250 ms, p99 399 ms (success 100.0%, sample 51840)
4. Limitless: Warm price p50 293 ms, p99 760 ms (success 100.0%, sample 51840)
5. Myriad: Warm price p50 516 ms, p99 4.23 s (success 99.7%, sample 51737)
6. Manifold: Warm price p50 6.50 s, p99 9.93 s (success 100.0%, sample 37029.9)

**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 3.5 min (p50, 24h) across 7 ranked venues.

**Rankings (p50 (median delay), 24h):**
1. Kalshi (All): p50 (median delay) 3.5 min, p99 14.7 min (success 100.0%, sample 21)
2. Kalshi (Sports): p50 (median delay) 3.5 min, p99 14.7 min (success 100.0%, sample 21)
3. Polymarket (Crypto): p50 (median delay) 10.4 min, p99 146.3 min (success 100.0%, sample 31465)
4. Polymarket (Sports): p50 (median delay) 50.1 min, p99 238.1 min (success 100.0%, sample 557118)
5. Polymarket (All): p50 (median delay) 120.9 min, p99 238.8 min (success 100.0%, sample 927445)
6. Polymarket (Other): p50 (median delay) 146.8 min, p99 239.6 min (success 100.0%, sample 330487)
7. Polymarket (Politics): p50 (median delay) 181.4 min, p99 569.9 min (success 100.0%, sample 8375)

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

**Rankings (p50, 24h):**
1. OpenSea: 97.1% (p99 97.1%, success 100.0%, sample 4531.57)
2. Alchemy: 94.4% (p99 94.4%, success 100.0%, sample 6002.08)

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

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

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

**Rankings (p50, 24h):**
1. Hyperliquid: $9.53B (p99 $12.31B, success 100.0%, sample 2880)
2. trade.xyz: $6.73B (p99 $7.50B, success 80.0%, sample 2880)
3. Kalshi: $3.77B (p99 $3.98B, success 79.9%, sample 2880)
4. Lighter: $2.91B (p99 $3.42B, success 100.0%, sample 2880)
5. Aster: $2.14B (p99 $2.65B, success 100.0%, sample 2880)
6. Jupiter Perps: $774.91M (p99 $1.65B, success 80.0%, sample 2880)
7. Pacifica: $768.64M (p99 $862.80M, success 83.3%, sample 2880)
8. Ondo Perps: $730.64M (p99 $831.04M, success 79.8%, sample 2880)
9. ApeX Omni: $706.95M (p99 $777.64M, success 80.0%, sample 2880)
10. Lighter RH: $694.38M (p99 $742.12M, success 80.0%, sample 2880)
11. GRVT: $578.75M (p99 $646.38M, success 83.3%, sample 2880)
12. Extended: $326.36M (p99 $386.13M, success 99.8%, sample 2880)
13. Nado: $225.65M (p99 $491.29M, success 82.9%, sample 2880)
14. Polymarket: $180.68M (p99 $218.35M, success 80.0%, sample 2880)
15. Vest: $166.15M (p99 $224.91M, success 75.0%, sample 2880)
16. Backpack: $137.93M (p99 $180.26M, success 50.0%, sample 2880)
17. GMX V2: $121.52M (p99 $137.57M, success 60.0%, sample 2880)
18. Orderly: $46.75M (p99 $72.49M, success 50.0%, sample 2880)
19. Gains: $24.64M (p99 $28.13M, success 100.0%, sample 2880)
20. dYdX v4: $10.54M (p99 $18.38M, success 100.0%, sample 2880)
21. Paradex: $4.87M (p99 $9.51M, success 100.0%, sample 2880)
22. Aevo: $4.21M (p99 $6.19M, success 81.0%, sample 2880)
23. Nova: $564.3K (p99 $888.7K, success 100.0%, sample 2880)
24. StandX: $16.8K (p99 $30.3K, success 80.0%, 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.
- Nova: the same read against Nova's own backend (backend-global.nova.markets). Nova runs the same gTrade software as Gains on Arbitrum, so the two rows are the same measurement on two separate books. Nova appears on no DefiLlama page (checked across all 8795 protocols on 2026-10-22), so its own backend is the only source and there is no second opinion to cross-check it against.
- 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: KuCoin and Polymarket both post the lowest 24h ETH funding stddev, tied at 0.022% (24h avg) across 17 ranked venues.

**Rankings (p50, 24h):**
1. KuCoin: 0.022% (p99 0.014%, success 100.0%, sample 2880)
2. Polymarket: 0.022% (p99 0.026%, success 100.0%, sample 2880)
3. Gate: 0.023% (p99 0.021%, success 100.0%, sample 2880)
4. Bitget: 0.023% (p99 0.0067%, success 100.0%, sample 2880)
5. Bybit: 0.027% (p99 0.026%, success 100.0%, sample 2880)
6. Vest: 0.027% (p99 0.017%, success 100.0%, sample 2880)
7. OKX: 0.027% (p99 0.018%, success 100.0%, sample 2880)
8. Kalshi: 0.028% (p99 0%, success 100.0%, sample 2880)
9. Paradex: 0.029% (p99 0.020%, success 100.0%, sample 2880)
10. Aster: 0.030% (p99 0.037%, success 100.0%, sample 2880)
11. MEXC: 0.030% (p99 0.029%, success 100.0%, sample 2880)
12. ApeX Omni: 0.033% (p99 0.018%, success 100.0%, sample 2880)
13. Binance: 0.033% (p99 0.027%, success 100.0%, sample 2880)
14. Kraken: 0.034% (p99 0.052%, success 100.0%, sample 2880)
15. Lighter: 0.043% (p99 0.032%, success 100.0%, sample 2880)
16. Hyperliquid: 0.044% (p99 0.029%, success 100.0%, sample 2880)
17. dYdX v4: 0.058% (p99 0.014%, success 100.0%, sample 2880)

**Methodology**:
- A stddev of zero is a property of the window, not of the venue. Most of the cohort quotes the same baseline when open interest is balanced, 0.01 percent per 8 hours, which normalizes to 3.00 bps per 24h hold: on 2026-10-21 nine of the twenty sat exactly there on ETH. Any venue holding the baseline for a full 24 hours reads zero and goes unranked, whatever its age. All of them move on a longer window, Polymarket between -0.26 and 3.00 bps over 30 days.
- 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 of the 24h hold cost on ETH over a 24 hour window, per venue, on whichever of the two funding metrics that venue is read from. A day is short enough that one settlement regime dominates, so the figure answers what the band looked like today rather than this 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. Nineteen venues, two sources. 8 polled directly (perp_funding_hold_24h_bps): Hyperliquid, Bybit, dYdX v4, Binance, OKX, Paradex, Polymarket, Aster. 11 via the Mobula CEFI aggregator (perp_venue_funding_24h_bps): Ondo Perps, Kalshi, Vest, StandX, ApeX Omni, Bitget, Gate, Kraken, KuCoin, Lighter, MEXC. Both normalize to bps per 24h hold, sign preserved. Deribit, edgeX, Extended, Pacifica and Lighter RH are ranked on perp-funding-cost-30d and are not on this bench.
- 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 8 free public Ethereum RPC endpoints measured, 27 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: p50 27 ms, p90 91 ms, p99 141 ms (success 99.3%, sample 4318.75)
2. PublicNode: p50 74 ms, p90 87 ms, p99 201 ms (success 100.0%, sample 4318.75)
3. Tenderly: p50 103 ms, p90 126 ms, p99 149 ms (success 100.0%, sample 4319.75)
4. Thyme Gate: p50 113 ms, p90 116 ms, p99 118 ms (success 100.0%, sample 4319.75)
5. BlockVectra: p50 117 ms, p90 299 ms, p99 456 ms (success 83.3%, sample 4317.75)
6. NOWNodes: p50 131 ms, p90 154 ms, p99 902 ms (success 90.2%, sample 4317.75)
7. Nodies: p50 142 ms, p90 185 ms, p99 263 ms (success 96.6%, sample 4318.76)
8. MeowRPC: p50 177 ms, p90 330 ms, p99 521 ms (success 99.7%, sample 4319.75)

**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 6 private (API-key) Ethereum RPC endpoints measured, 9 ms (p50, 24h, 3 regions).
1. GetBlock: 9 ms (p99 35 ms, success 100.0%, sample 1079.19)
2. Alchemy: 10 ms (p99 54 ms, success 100.0%, sample 1080.19)
3. Quicknode: 12 ms (p99 41 ms, success 100.0%, sample 1080.19)
4. Chainstack: 20 ms (p99 61 ms, success 98.2%, sample 1075.19)
5. Dwellir: 35 ms (p99 143 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 106 ms (p99 172 ms, success 100.0%, sample 1078.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/ethereum-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/ethereum-rpc?tier=keyed-cold
- Headline: GetBlock has the lowest median latency of the 6 free public Ethereum RPC endpoints measured, 28 ms (p50, 24h, 3 regions).
1. GetBlock: 28 ms (p99 211 ms, success 100.0%, sample 1080.19)
2. Quicknode: 29 ms (p99 262 ms, success 100.0%, sample 1080.19)
3. Alchemy: 34 ms (p99 130 ms, success 100.0%, sample 1080.19)
4. Chainstack: 70 ms (p99 149 ms, success 98.6%, sample 1077.19)
5. BlockMachine: 174 ms (p99 341 ms, success 100.0%, sample 1080.19)
6. Dwellir: 192 ms (p99 650 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/ethereum-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/ethereum-rpc?tier=keyed-heavy
- Headline: GetBlock has the lowest median latency of the 6 free public Ethereum RPC endpoints measured, 11 ms (p50, 24h, 3 regions).
1. GetBlock: 11 ms (p99 23 ms, success 100.0%, sample 42)
2. Alchemy: 13 ms (p99 122 ms, success 100.0%, sample 42)
3. Quicknode: 17 ms (p99 41 ms, success 100.0%, sample 42)
4. Chainstack: 34 ms (p99 124 ms, success 100.0%, sample 42)
5. Dwellir: 41 ms (p99 115 ms, success 100.0%, sample 42)
6. BlockMachine: 122 ms (p99 179 ms, success 100.0%, sample 42)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 8 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, Quicknode, Dwellir and BlockMachine 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: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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 7 free public Arbitrum RPC endpoints measured, 40 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: p50 40 ms, p90 56 ms, p99 114 ms (success 99.7%, sample 4317.75)
2. PublicNode: p50 78 ms, p90 91 ms, p99 226 ms (success 100.0%, sample 4319.75)
3. Tenderly: p50 105 ms, p90 112 ms, p99 125 ms (success 100.0%, sample 4320.75)
4. BlockVectra: p50 112 ms, p90 138 ms, p99 331 ms (success 92.2%, sample 4320.75)
5. Arbitrum: p50 125 ms, p90 133 ms, p99 193 ms (success 100.0%, sample 4320.75)
6. Nodies: p50 135 ms, p90 149 ms, p99 181 ms (success 100.0%, sample 4318.75)
7. MeowRPC: p50 199 ms, p90 275 ms, p99 341 ms (success 100.0%, sample 4319.75)

**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: Quicknode has the lowest median latency of the 6 private (API-key) Arbitrum RPC endpoints measured, 4 ms (p50, 24h, 3 regions).
1. Quicknode: 4 ms (p99 18 ms, success 100.0%, sample 1078.19)
2. GetBlock: 8 ms (p99 48 ms, success 100.0%, sample 1080.19)
3. Alchemy: 9 ms (p99 129 ms, success 100.0%, sample 1080.19)
4. Chainstack: 20 ms (p99 35 ms, success 100.0%, sample 1079.19)
5. Dwellir: 40 ms (p99 115 ms, success 100.0%, sample 1078.19)
6. BlockMachine: 112 ms (p99 164 ms, success 100.0%, sample 1080.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/arbitrum-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/arbitrum-rpc?tier=keyed-cold
- Headline: Quicknode has the lowest median latency of the 6 free public Arbitrum RPC endpoints measured, 25 ms (p50, 24h, 3 regions).
1. Quicknode: 25 ms (p99 136 ms, success 100.0%, sample 1080.19)
2. GetBlock: 26 ms (p99 105 ms, success 100.0%, sample 1080.19)
3. Alchemy: 35 ms (p99 261 ms, success 100.0%, sample 1080.19)
4. Chainstack: 68 ms (p99 557 ms, success 100.0%, sample 1080.19)
5. Dwellir: 205 ms (p99 525 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 283 ms (p99 534 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/arbitrum-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/arbitrum-rpc?tier=keyed-heavy
- Headline: GetBlock has the lowest median latency of the 6 free public Arbitrum RPC endpoints measured, 11 ms (p50, 24h, 3 regions).
1. GetBlock: 11 ms (p99 30 ms, success 100.0%, sample 42)
2. Quicknode: 12 ms (p99 92 ms, success 100.0%, sample 42)
3. Alchemy: 14 ms (p99 34 ms, success 100.0%, sample 42)
4. Chainstack: 25 ms (p99 43 ms, success 100.0%, sample 42)
5. Dwellir: 43 ms (p99 103 ms, success 100.0%, sample 42)
6. BlockMachine: 126 ms (p99 165 ms, success 100.0%, sample 41)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 7 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, Quicknode, Dwellir and BlockMachine 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: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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, 78 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: p50 78 ms, p90 92 ms, p99 266 ms (success 99.5%, sample 4320.75)
2. dRPC: p50 89 ms, p90 108 ms, p99 165 ms (success 94.0%, sample 4319.75)
3. Tenderly: p50 103 ms, p90 111 ms, p99 122 ms (success 100.0%, sample 4319.75)
4. Base (Coinbase): p50 104 ms, p90 111 ms, p99 139 ms (success 100.0%, sample 4319.75)
5. Nodies: p50 117 ms, p90 148 ms, p99 195 ms (success 99.9%, sample 4317.75)

**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: Chainstack has the lowest median latency of the 6 private (API-key) Base RPC endpoints measured, 5 ms (p50, 24h, 3 regions).
1. Chainstack: 5 ms (p99 63 ms, success 98.1%, sample 1078.19)
2. Quicknode: 6 ms (p99 16 ms, success 100.0%, sample 1079.19)
3. GetBlock: 9 ms (p99 40 ms, success 100.0%, sample 1080.19)
4. Dwellir: 10 ms (p99 35 ms, success 100.0%, sample 1079.19)
5. Alchemy: 11 ms (p99 47 ms, success 100.0%, sample 1079.19)
6. BlockMachine: 111 ms (p99 177 ms, success 100.0%, sample 1079.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/base-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/base-rpc?tier=keyed-cold
- Headline: GetBlock has the lowest median latency of the 6 free public Base RPC endpoints measured, 23 ms (p50, 24h, 3 regions).
1. GetBlock: 23 ms (p99 94 ms, success 100.0%, sample 1080.19)
2. Chainstack: 28 ms (p99 181 ms, success 97.2%, sample 1080.19)
3. Alchemy: 33 ms (p99 423 ms, success 100.0%, sample 1079.19)
4. Quicknode: 34 ms (p99 222 ms, success 100.0%, sample 1080.19)
5. Dwellir: 106 ms (p99 336 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 285 ms (p99 448 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/base-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/base-rpc?tier=keyed-heavy
- Headline: Quicknode has the lowest median latency of the 6 free public Base RPC endpoints measured, 9 ms (p50, 24h, 3 regions).
1. Quicknode: 9 ms (p99 13 ms, success 100.0%, sample 42)
2. Chainstack: 10 ms (p99 19 ms, success 100.0%, sample 42)
3. GetBlock: 10 ms (p99 16 ms, success 100.0%, sample 42)
4. Dwellir: 15 ms (p99 42 ms, success 100.0%, sample 42)
5. Alchemy: 15 ms (p99 198 ms, success 100.0%, sample 42)
6. BlockMachine: 129 ms (p99 155 ms, success 100.0%, sample 42)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, Quicknode, Dwellir and BlockMachine 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: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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 7 free public Optimism RPC endpoints measured, 75 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 75 ms (p99 207 ms, success 100.0%, sample 4318.75)
2. dRPC: 87 ms (p99 170 ms, success 94.7%, sample 4320.75)
3. Tenderly: 103 ms (p99 128 ms, success 100.0%, sample 4320.75)
4. BlockVectra: 112 ms (p99 331 ms, success 99.9%, sample 4318.75)
5. Nodies: 141 ms (p99 203 ms, success 100.0%, sample 4318.75)
6. Thyme Gate: 142 ms (p99 175 ms, success 100.0%, sample 4318.75)
7. Optimism: 155 ms (p99 242 ms, success 100.0%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 7 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, 75 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 75 ms (p99 163 ms, success 100.0%, sample 4318.75)
2. Avalanche: 81 ms (p99 146 ms, success 100.0%, sample 4320.75)
3. Tenderly: 106 ms (p99 122 ms, success 100.0%, sample 4320.75)
4. dRPC: 162 ms (p99 450 ms, success 99.4%, sample 4316.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: bloXroute has the lowest median latency of the 5 free public BNB Chain RPC endpoints measured, 16 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. bloXroute: p50 16 ms, p90 58 ms, p99 100 ms (success 100.0%, sample 4319.75)
2. Binance: p50 32 ms, p90 39 ms, p99 171 ms (success 100.0%, sample 4318.75)
3. PublicNode: p50 76 ms, p90 105 ms, p99 241 ms (success 100.0%, sample 4317.75)
4. Thyme Gate: p50 142 ms, p90 147 ms, p99 169 ms (success 99.4%, sample 4316.75)
5. NOWNodes: p50 143 ms, p90 179 ms, p99 368 ms (success 99.7%, sample 4315.75)

**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: Quicknode has the lowest median latency of the 6 private (API-key) BNB Chain RPC endpoints measured, 5 ms (p50, 24h, 3 regions).
1. Quicknode: 5 ms (p99 25 ms, success 100.0%, sample 1080.19)
2. Alchemy: 10 ms (p99 49 ms, success 100.0%, sample 1079.19)
3. GetBlock: 10 ms (p99 60 ms, success 100.0%, sample 1080.19)
4. Chainstack: 19 ms (p99 42 ms, success 98.9%, sample 1079.19)
5. Dwellir: 34 ms (p99 75 ms, success 100.0%, sample 1079.19)
6. BlockMachine: 115 ms (p99 180 ms, success 100.0%, sample 1080.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/bnb-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/bnb-rpc?tier=keyed-cold
- Headline: GetBlock has the lowest median latency of the 6 free public BNB Chain RPC endpoints measured, 28 ms (p50, 24h, 3 regions).
1. GetBlock: 28 ms (p99 222 ms, success 100.0%, sample 1080.19)
2. Quicknode: 32 ms (p99 130 ms, success 100.0%, sample 1080.19)
3. Alchemy: 37 ms (p99 213 ms, success 100.0%, sample 1080.19)
4. Chainstack: 64 ms (p99 143 ms, success 99.4%, sample 1080.19)
5. Dwellir: 184 ms (p99 397 ms, success 99.8%, sample 1080.19)
6. BlockMachine: 293 ms (p99 572 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/bnb-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/bnb-rpc?tier=keyed-heavy
- Headline: GetBlock has the lowest median latency of the 6 free public BNB Chain RPC endpoints measured, 13 ms (p50, 24h, 3 regions).
1. GetBlock: 13 ms (p99 23 ms, success 100.0%, sample 42)
2. Quicknode: 14 ms (p99 33 ms, success 100.0%, sample 42)
3. Alchemy: 15 ms (p99 35 ms, success 100.0%, sample 42)
4. Chainstack: 36 ms (p99 46 ms, success 100.0%, sample 42)
5. Dwellir: 37 ms (p99 76 ms, success 100.0%, sample 42)
6. BlockMachine: 137 ms (p99 184 ms, success 100.0%, sample 41)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 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, Quicknode, Dwellir and BlockMachine 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: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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 4 free public Polygon RPC endpoints measured, 30 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: p50 30 ms, p90 120 ms, p99 246 ms (success 99.7%, sample 4317.75)
2. PublicNode: p50 77 ms, p90 92 ms, p99 234 ms (success 99.5%, sample 4319.75)
3. Tenderly: p50 99 ms, p90 112 ms, p99 138 ms (success 100.0%, sample 4318.75)
4. Thyme Gate: p50 123 ms, p90 128 ms, p99 134 ms (success 100.0%, sample 4318.75)

**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: Quicknode has the lowest median latency of the 6 private (API-key) Polygon RPC endpoints measured, 4 ms (p50, 24h, 3 regions).
1. Quicknode: 4 ms (p99 27 ms, success 100.0%, sample 1080.19)
2. GetBlock: 9 ms (p99 83 ms, success 100.0%, sample 1080.19)
3. Alchemy: 9 ms (p99 45 ms, success 100.0%, sample 1080.19)
4. Chainstack: 28 ms (p99 59 ms, success 99.6%, sample 1079.19)
5. Dwellir: 92 ms (p99 257 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 108 ms (p99 166 ms, success 100.0%, sample 1080.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/polygon-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/polygon-rpc?tier=keyed-cold
- Headline: Quicknode has the lowest median latency of the 6 free public Polygon RPC endpoints measured, 24 ms (p50, 24h, 3 regions).
1. Quicknode: 24 ms (p99 106 ms, success 100.0%, sample 1079.19)
2. GetBlock: 27 ms (p99 205 ms, success 100.0%, sample 1080.19)
3. Alchemy: 35 ms (p99 154 ms, success 100.0%, sample 1080.19)
4. Chainstack: 95 ms (p99 323 ms, success 99.7%, sample 1080.19)
5. BlockMachine: 218 ms (p99 401 ms, success 100.0%, sample 1080.19)
6. Dwellir: 353 ms (p99 863 ms, success 100.0%, sample 1079.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/polygon-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/polygon-rpc?tier=keyed-heavy
- Headline: Quicknode has the lowest median latency of the 6 free public Polygon RPC endpoints measured, 10 ms (p50, 24h, 3 regions).
1. Quicknode: 10 ms (p99 19 ms, success 100.0%, sample 43)
2. GetBlock: 11 ms (p99 16 ms, success 100.0%, sample 43)
3. Alchemy: 13 ms (p99 34 ms, success 100.0%, sample 43)
4. Chainstack: 54 ms (p99 180 ms, success 100.0%, sample 43)
5. Dwellir: 99 ms (p99 150 ms, success 100.0%, sample 43)
6. BlockMachine: 128 ms (p99 161 ms, success 100.0%, sample 42)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 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): Alchemy, Chainstack, GetBlock, Quicknode, Dwellir and BlockMachine 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: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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, 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 79 ms (p99 261 ms, success 100.0%, sample 4317.75)
2. Tenderly: 154 ms (p99 218 ms, success 100.0%, sample 4320.75)
3. dRPC: 198 ms (p99 498 ms, success 99.3%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 78 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 78 ms (p99 237 ms, success 100.0%, sample 4319.75)
2. Tenderly: 154 ms (p99 216 ms, success 100.0%, sample 4320.75)
3. dRPC: 193 ms (p99 452 ms, success 99.1%, sample 4319.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 79 ms (p99 258 ms, success 100.0%, sample 4319.75)
2. Tenderly: 105 ms (p99 120 ms, success 100.0%, sample 4317.75)
3. dRPC: 227 ms (p99 1.75 s, success 53.0%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: Aster posts the lowest slippage at $100k at 0.0031% (24h avg) across 9 ranked venues.

**Rankings (p50, 24h):**
1. Aster: 0.0031% (p99 0.025%, success 100.0%, sample 2880)
2. Extended: 0.0066% (p99 0.025%, success 100.0%, sample 2880)
3. Hyperliquid: 0.0068% (p99 0.029%, success 100.0%, sample 2880)
4. edgeX: 0.0082% (p99 0.040%, success 100.0%, sample 2880)
5. Lighter: 0.011% (p99 0.034%, success 100.0%, sample 2880)
6. Polymarket: 0.015% (p99 0.13%, success 100.0%, sample 2880)
7. dYdX v4: 0.069% (p99 0.14%, success 100.0%, sample 2880)
8. Ondo Perps: 0.11% (p99 1.68%, success 100.0%, sample 2870)
9. Paradex: 0.19% (p99 1.52%, 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, 76 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 220 ms, success 100.0%, sample 4318.75)
2. Tenderly: 106 ms (p99 122 ms, success 100.0%, sample 4318.75)
3. Sonic Labs: 111 ms (p99 137 ms, success 100.0%, sample 4319.75)
4. dRPC: 162 ms (p99 482 ms, success 99.8%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 81 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 81 ms (p99 269 ms, success 99.6%, sample 4317.75)
2. Tenderly: 106 ms (p99 140 ms, success 100.0%, sample 4319.75)
3. dRPC: 150 ms (p99 210 ms, success 99.0%, sample 4319.75)
4. Gnosis: 174 ms (p99 615 ms, success 100.0%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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.

## 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: OnFinality is the only free public Moonbeam RPC endpoint measured, at 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 79 ms (p99 7.20 s, success 91.8%, sample 4316.76)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest",false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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.
- Cohort rebuilt 2026-10-09. Dropped: PublicNode and Tenderly, both 404, and the Foundation endpoint, which refuses the TLS handshake from two independent client stacks (LibreSSL 3.3.6 and OpenSSL 3.5.5), so it cannot be measured from here whatever the cause. Added: OnFinality and UnitedBloc, each probed with `eth_getBlockByNumber` and kept only after returning dRPC's head on 10 of 10 tries.

## 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 5 free public Unichain RPC endpoints measured, 78 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 78 ms (p99 190 ms, success 100.0%, sample 4320.75)
2. Tenderly: 105 ms (p99 127 ms, success 100.0%, sample 4320.75)
3. BlockVectra: 111 ms (p99 333 ms, success 100.0%, sample 4319.75)
4. Unichain (Uniswap Labs): 117 ms (p99 374 ms, success 100.0%, sample 4318.75)
5. dRPC: 123 ms (p99 211 ms, success 99.5%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 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.

## 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, 62 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Berachain: 62 ms (p99 65 ms, success 100.0%, sample 4320.75)
2. PublicNode: 80 ms (p99 235 ms, success 99.5%, sample 4318.75)
3. dRPC: 141 ms (p99 244 ms, success 99.7%, sample 4316.75)
4. Tenderly: 151 ms (p99 201 ms, success 100.0%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: zkSync has the lowest median latency of the 3 free public zkSync Era RPC endpoints measured, 129 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. zkSync: 129 ms (p99 1.53 s, success 100.0%, sample 4315.75)
2. dRPC: 148 ms (p99 621 ms, success 99.1%, sample 4319.75)
3. Tenderly: 156 ms (p99 192 ms, success 100.0%, sample 4321.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 57 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Cronos: 57 ms (p99 221 ms, success 100.0%, sample 4316.75)
2. PublicNode: 80 ms (p99 255 ms, success 100.0%, sample 4317.75)
3. dRPC: 122 ms (p99 209 ms, success 99.6%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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 5 free public Fraxtal RPC endpoints measured, 34 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Fraxtal: 34 ms (p99 155 ms, success 100.0%, sample 4320.75)
2. PublicNode: 80 ms (p99 230 ms, success 100.0%, sample 4319.75)
3. Tenderly: 97 ms (p99 120 ms, success 100.0%, sample 4320.75)
4. BlockVectra: 112 ms (p99 330 ms, success 100.0%, sample 4319.75)
5. dRPC: 130 ms (p99 240 ms, success 99.6%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 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.

## 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, 30 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Monad: 30 ms (p99 83 ms, success 99.8%, sample 4314.75)
2. OnFinality: 86 ms (p99 1.94 s, success 100.0%, sample 4320.75)
3. Tenderly Gateway: 106 ms (p99 152 ms, success 100.0%, sample 4318.75)
4. dRPC: 142 ms (p99 210 ms, success 100.0%, sample 4318.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 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 22 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. MegaETH Official: 22 ms (p99 66 ms, success 100.0%, sample 4319.75)
2. dRPC: 97 ms (p99 186 ms, success 99.4%, sample 4314.75)
3. Tenderly Gateway: 106 ms (p99 132 ms, 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 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 48 Club Privacy RPC posts the lowest wallet call latency at 19 ms (p50, 24h) across 6 ranked providers.

**Rankings (p50, 24h):**
1. 48 Club Privacy RPC: 19 ms (p99 39 ms, success 100.0%, sample 30240.5)
2. bloXroute Protect: 29 ms (p99 35 ms, success 100.0%, sample 60481)
3. PancakeSwap MEV Guard: 39 ms (p99 49 ms, success 100.0%, sample 30240.5)
4. MEV Blocker: 112 ms (p99 128 ms, success 100.0%, sample 30240.5)
5. Flashbots Protect: 128 ms (p99 148 ms, success 100.0%, sample 30240.5)
6. BlockSec Anti-MEV: 142 ms (p99 170 ms, success 100.0%, sample 60481)

**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, 32 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Solana Labs: p50 32 ms, p90 383 ms, p99 1.98 s (success 99.9%, sample 4318.75)
2. PublicNode: p50 73 ms, p90 84 ms, p99 135 ms (success 97.5%, sample 4318.75)
3. Solana Vibe Station: p50 90 ms, p90 97 ms, p99 315 ms (success 100.0%, sample 4319.75)
4. LeoRPC: p50 352 ms, p90 391 ms, p99 483 ms (success 73.0%, sample 4317.75)

**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: Quicknode has the lowest median latency of the 6 private (API-key) Solana RPC endpoints measured, 4 ms (p50, 24h, 3 regions).
1. Quicknode: 4 ms (p99 19 ms, success 100.0%, sample 1080.19)
2. FluxRPC: 4 ms (p99 5 ms, success 98.8%, sample 720.125)
3. Chainstack: 7 ms (p99 70 ms, success 99.9%, sample 1079.19)
4. GetBlock: 8 ms (p99 39 ms, success 100.0%, sample 1080.19)
5. Alchemy: 9 ms (p99 36 ms, success 100.0%, sample 1080.19)
6. Helius: 13 ms (p99 47 ms, success 100.0%, sample 1080.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/solana-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/solana-rpc?tier=keyed-cold
- Headline: GetBlock has the lowest median latency of the 6 free public Solana RPC endpoints measured, 20 ms (p50, 24h, 3 regions).
1. GetBlock: 20 ms (p99 104 ms, success 100.0%, sample 1080.19)
2. FluxRPC: 21 ms (p99 96 ms, success 98.9%, sample 720.125)
3. Quicknode: 24 ms (p99 396 ms, success 100.0%, sample 1080.19)
4. Helius: 29 ms (p99 231 ms, success 100.0%, sample 1080.19)
5. Chainstack: 33 ms (p99 177 ms, success 99.8%, sample 1080.19)
6. Alchemy: 36 ms (p99 407 ms, success 100.0%, sample 1079.19)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west 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), Shyft + BlockEden (key-gated).
- Private cohort (Access selector, Private): Alchemy, Chainstack, GetBlock, Quicknode and Helius 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: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Helius plan tier, disclosed: a Free plan key, 1 million credits a month, shared by the three probe regions. Helius is the only Solana-native provider in this cohort; the others serve Solana alongside EVM chains, which is worth knowing when reading the getProgramAccounts columns.
- 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 18.8 bps (p50, 7d) across 6 ranked tokenized stocks.

**Rankings (p50, 7d):**
1. META: 18.8 bps (p99 42.6 bps, success 99.9%, sample 1949)
2. NVDA: 20.3 bps (p99 47.4 bps, success 99.9%, sample 1949)
3. AMD: 50.4 bps (p99 118 bps, success 99.9%, sample 1949)
4. MU: 56.7 bps (p99 117 bps, success 99.9%, sample 1949)
5. PLTR: 58.5 bps (p99 116 bps, success 99.9%, sample 1949)
6. AAPL: 79.1 bps (p99 139 bps, success 99.9%, 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: AAPLx posts the lowest price deviation at 3.91 bps (p50, 7d) across 12 ranked tokenized stocks.

**Rankings (p50, 7d):**
1. AAPLx: 3.91 bps (p99 14.9 bps, success 100.0%, sample 1945)
2. TSLAx: 4.02 bps (p99 19.8 bps, success 100.0%, sample 1945)
3. GOOGLx: 4.11 bps (p99 21.2 bps, success 100.0%, sample 1945)
4. METAx: 4.20 bps (p99 19.5 bps, success 100.0%, sample 1945)
5. AMZNx: 4.63 bps (p99 25.9 bps, success 100.0%, sample 1945)
6. SPYx: 6.28 bps (p99 22.6 bps, success 100.0%, sample 1945)
7. HOODx: 6.34 bps (p99 37.1 bps, success 100.0%, sample 1945)
8. MSFTx: 7.11 bps (p99 22.2 bps, success 100.0%, sample 1945)
9. QQQx: 7.43 bps (p99 18.8 bps, success 100.0%, sample 1945)
10. PLTRx: 8.19 bps (p99 32.7 bps, success 100.0%, sample 1945)
11. NVDAx: 9.16 bps (p99 31.5 bps, success 100.0%, sample 1945)
12. COINx: 10.8 bps (p99 42.5 bps, success 100.0%, sample 1945)

**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 33.9 bps (p50, 24h) across 2 ranked providers.

**Rankings (|Basis| 24h median, 24h):**
1. Orca (Solana): |Basis| 24h median 33.9 bps, |Basis| p90 35.3 bps, |Basis| p99 36.9 bps, |Basis| mean 34.0 bps (success 100.0%, sample 1440)
2. Jupiter route (Solana): |Basis| 24h median 33.9 bps, |Basis| p90 35.3 bps, |Basis| p99 36.9 bps, |Basis| mean 34.0 bps (success 100.0%, sample 1440)

**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: AAPL posts the lowest weekend max drift at 4.07 bps (latest value) across 6 ranked tokenized stocks.

**Rankings (p50, 7d):**
1. AAPL: 4.07 bps (p99 4.07 bps, success 99.9%, sample 6)
2. META: 189 bps (p99 189 bps, success 99.9%, sample 6)
3. PLTR: 228 bps (p99 228 bps, success 99.9%, sample 6)
4. NVDA: 403 bps (p99 403 bps, success 99.9%, sample 6)
5. AMD: 524 bps (p99 524 bps, success 99.9%, sample 6)
6. MU: 550 bps (p99 550 bps, success 99.9%, 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: First to push (pct)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-ethereum
- JSON: https://openchainbench.com/api/stat/ws-head-latency-ethereum
- Status: live
- Headline: PublicNode leads first to push at 84.9% (24h avg) across 3 ranked providers.

**Rankings (p50, 24h):**
1. PublicNode: 84.9% (p99 84.9%, success 99.9%, sample 28646.9)
2. dRPC: 14.8% (p99 14.8%, success 100.0%, sample 28667)
3. Tenderly: 0.43% (p99 0.43%, success 100.0%, sample 28661)

**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).
- Race scoring: the first provider to deliver block N in a region wins it. The published figure is each provider's share of first arrivals among the blocks it received, pooled over 24 hours, so a provider raced from fewer regions is not diluted by the others. A block's cohort closes 5 seconds after the first arrival; a provider arriving later is scored as a missed block (ws_block_gap_total).
- 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.
- 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.
- 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).
- Why a share and not a lag: a single vantage point cannot separate its own network path from a provider's push pipeline, so the race compares arrivals over the same path. The winner's lag is zero by construction and a median lag mostly measures how often a provider wins; the share of first arrivals states it directly.
- Coverage: ws_head_blocks_seen_total per provider divided by the cohort maximum over the same 24h window, clamped to 1. A provider that wins the races it runs but skips blocks loses on this column.
- Regions: one harness per region (us-east, eu-west, Singapore), each block raced within its region. Geography moves absolute arrival times for every provider over the same path; a provider whose nearest edge is far from a region is disadvantaged there, which is why each region has its own tab.

## 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: PublicNode, Tenderly, Flashbots and Arbitrum and 1 more all post the lowest reliability incidents, tied at 0 (24h) across 9 ranked providers.

**Rankings (Incidents 24h, 24h):**
1. PublicNode: Incidents 24h 0, Head lag p90 0, Head lag p99 0.033 (success 100.0%, sample 574.199)
2. Tenderly: Incidents 24h 0, Head lag p90 0.091, Head lag p99 0.318 (success 100.0%, sample 494.172)
3. Flashbots: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 84.0292)
4. Arbitrum: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 84.0292)
5. Optimism: Incidents 24h 0, Head lag p90 0, Head lag p99 0 (success 100.0%, sample 82.0285)
6. Nodies: Incidents 24h 2, Head lag p90 0, Head lag p99 0 (success 99.4%, sample 330.114)
7. Base: Incidents 24h 40, Head lag p90 0, Head lag p99 0 (success 50.0%, sample 80.0278)
8. Binance: Incidents 24h 40, Head lag p90 0, Head lag p99 0 (success 50.0%, sample 80.0278)
9. dRPC: Incidents 24h 57, Head lag p90 0, Head lag p99 0.033 (success 88.7%, sample 494.171)

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

**Rankings (p50, 24h):**
1. Titan: 54.0% (p99 54.0%, success 100.0%, sample 3873.34)
2. Quasar: 16.5% (p99 16.5%, success 100.0%, sample 1179.41)
3. BuilderNet: 8.66% (p99 8.66%, success 100.0%, sample 621.216)
4. Vanilla: 6.85% (p99 6.85%, success 100.0%, sample 491.171)
5. Eureka: 6.07% (p99 6.07%, success 100.0%, sample 435.151)
6. Other: 5.53% (p99 5.53%, success 100.0%, sample 396.138)
7. Builder+: 1.45% (p99 1.45%, success 100.0%, sample 104.036)
8. Bob The Builder: 0.87% (p99 0.87%, success 100.0%, sample 62.0215)
9. beaverbuild: 0.014% (p99 0.014%, success 100.0%, sample 1.00035)

**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: six MEV-Boost relay data APIs (Flashbots, ultrasound, Agnostic, 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, 50 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 50 ms (p99 1.87 s, success 100.0%, sample 4318.75)
2. PublicNode: 86 ms (p99 294 ms, success 100.0%, sample 4319.75)
3. Parity: 108 ms (p99 349 ms, success 100.0%, sample 4316.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":"chain_getHeader","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: First to push (pct)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-base
- JSON: https://openchainbench.com/api/stat/ws-head-latency-base
- Status: live
- Headline: PublicNode leads first to push at 11.3% (24h avg) across 1 ranked provider.

**Rankings (p50, 24h):**
1. PublicNode: 11.3% (p99 11.3%, success 100.0%, sample 1725170)

**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.
- Race scoring: the first provider to deliver block N in a region wins it. The published figure is each provider's share of first arrivals among the blocks it received, pooled over 24 hours, so a provider raced from fewer regions is not diluted by the others. A block's cohort closes 5 seconds after the first arrival; a provider arriving later is scored as a missed block (ws_block_gap_total).
- 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.
- 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.
- Why a share and not a lag: a single vantage point cannot separate its own network path from a provider's push pipeline, so the race compares arrivals over the same path. The winner's lag is zero by construction and a median lag mostly measures how often a provider wins; the share of first arrivals states it directly.
- Coverage: ws_head_blocks_seen_total per provider divided by the cohort maximum over the same 24h window, clamped to 1. A provider that wins the races it runs but skips blocks loses on this column.
- Regions: one harness per region (us-east, eu-west, Singapore), each block raced within its region. Geography moves absolute arrival times for every provider over the same path; a provider whose nearest edge is far from a region is disadvantaged there, which is why each region has its own tab.

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

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/ws-head-latency-solana
- JSON: https://openchainbench.com/api/stat/ws-head-latency-solana
- Status: live
- Headline: PublicNode leads first to push at 64.5% (24h avg) across 2 ranked providers.

**Rankings (p50, 24h):**
1. PublicNode: 64.5% (p99 64.5%, success 100.0%, sample 1602790)
2. Solana: 40.4% (p99 40.4%, success 66.8%, sample 1070470)

**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.
- Race scoring: the first provider to deliver slot N in a region wins it. The published figure is each provider's share of first arrivals among the slots it received, pooled over 24 hours, so a provider raced from fewer regions is not diluted by the others. A slot's cohort closes 5 seconds after the first arrival; a provider arriving later is scored as a missed slot (ws_block_gap_total).
- 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.
- 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.
- Why a share and not a lag: a single vantage point cannot separate its own network path from a provider's push pipeline, so the race compares arrivals over the same path. The winner's lag is zero by construction and a median lag mostly measures how often a provider wins; the share of first arrivals states it directly.
- Coverage: ws_head_blocks_seen_total per provider divided by the cohort maximum over the same 24h window, clamped to 1. A provider that wins the races it runs but skips slots loses on this column.
- Regions: one harness per region (us-east, eu-west, Singapore), each slot raced within its region. Geography moves absolute arrival times for every provider over the same path; a provider whose nearest edge is far from a region is disadvantaged there, which is why each region has its own tab.

## 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 5.00 bps (30d avg) across 4 ranked tokens.

**Rankings (|Deviation| 30d, 30d):**
1. USDY: |Deviation| 30d 5.00 bps, Signed 30d 5.00 bps, Delivered 30d 362 bps, |Deviation| 7d 18.0 bps (success 100.0%, sample 663)
2. USTB: |Deviation| 30d 16.0 bps, Signed 30d 16.0 bps, Delivered 30d 368 bps, |Deviation| 7d 17.0 bps (success 100.0%, sample 663)
3. SyrupUSDC: |Deviation| 30d 17.0 bps, Signed 30d 17.0 bps, Delivered 30d 516 bps, |Deviation| 7d 26.0 bps (success 100.0%, sample 663)
4. OUSG: |Deviation| 30d 27.0 bps, Signed 30d 27.0 bps, Delivered 30d 372 bps, |Deviation| 7d 35.0 bps (success 100.0%, sample 663)

**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 222 (24h) across 4 ranked providers.

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

**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 4 free public Osmosis RPC endpoints measured, 80 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 80 ms (p99 302 ms, success 100.0%, sample 4317.75)
2. Osmosis Foundation: 120 ms (p99 605 ms, success 99.6%, sample 4319.75)
3. Polkachu: 127 ms (p99 253 ms, success 100.0%, sample 4317.75)
4. LavenderFive: 140 ms (p99 539 ms, success 99.8%, sample 4316.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 4 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: dRPC has the lowest median latency of the 5 free public Hyperliquid RPC endpoints measured, 67 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: p50 67 ms, p90 90 ms, p99 203 ms (success 99.1%, sample 4319.75)
2. Purroof Group: p50 129 ms, p90 135 ms, p99 139 ms (success 100.0%, sample 4318.75)
3. Hyperliquid Labs: p50 152 ms, p90 175 ms, p99 225 ms (success 93.5%, sample 4317.76)
4. Hypurrscan: p50 170 ms, p90 210 ms, p99 494 ms (success 97.9%, sample 4313.76)
5. Stakely: p50 412 ms, p90 878 ms, p99 2.49 s (success 99.0%, sample 4315.75)

**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 5 private (API-key) Hyperliquid RPC endpoints measured, 6 ms (p50, 24h, 3 regions).
1. Quicknode: 6 ms (p99 17 ms, success 100.0%, sample 1079.19)
2. Alchemy: 8 ms (p99 166 ms, success 100.0%, sample 1080.19)
3. Dwellir: 10 ms (p99 94 ms, success 100.0%, sample 1080.19)
4. Chainstack: 48 ms (p99 107 ms, success 100.0%, sample 1080.19)
5. GetBlock: 85 ms (p99 198 ms, success 99.4%, sample 1078.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/hyperliquid-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/hyperliquid-rpc?tier=keyed-cold
- Headline: Quicknode has the lowest median latency of the 5 free public Hyperliquid RPC endpoints measured, 31 ms (p50, 24h, 3 regions).
1. Quicknode: 31 ms (p99 133 ms, success 100.0%, sample 1080.19)
2. Alchemy: 33 ms (p99 687 ms, success 100.0%, sample 1080.19)
3. GetBlock: 103 ms (p99 247 ms, success 99.2%, sample 1079.19)
4. Dwellir: 116 ms (p99 352 ms, success 100.0%, sample 1080.19)
5. Chainstack: 154 ms (p99 326 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/hyperliquid-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/hyperliquid-rpc?tier=keyed-heavy
- Headline: Quicknode has the lowest median latency of the 5 free public Hyperliquid RPC endpoints measured, 8 ms (p50, 24h, 3 regions).
1. Quicknode: 8 ms (p99 74 ms, success 100.0%, sample 42)
2. Alchemy: 13 ms (p99 39 ms, success 100.0%, sample 42)
3. Dwellir: 13 ms (p99 161 ms, success 100.0%, sample 42)
4. Chainstack: 94 ms (p99 167 ms, success 100.0%, sample 42)
5. GetBlock: 162 ms (p99 288 ms, success 100.0%, sample 42)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, Quicknode and Dwellir 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: an enterprise key, not the tier a reader gets; Alchemy states free and paid keys share one routing; Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the three probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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, 42 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. TronGrid: 42 ms (p99 196 ms, success 100.0%, sample 4320.75)
2. PublicNode: 85 ms (p99 329 ms, success 100.0%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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 4 free public Cosmos Hub RPC endpoints measured, 81 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 81 ms (p99 248 ms, success 100.0%, sample 4321.75)
2. ecostake: 122 ms (p99 195 ms, success 100.0%, sample 4317.75)
3. Polkachu: 126 ms (p99 203 ms, success 99.9%, sample 4318.75)
4. LavenderFive: 168 ms (p99 598 ms, success 100.0%, sample 4318.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 4 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, 83 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 83 ms (p99 239 ms, success 100.0%, sample 4320.75)
2. Polkachu: 124 ms (p99 239 ms, success 98.8%, sample 4315.75)
3. LavenderFive: 169 ms (p99 584 ms, success 99.6%, sample 4320.76)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: Stake&Relax has the lowest median latency of the 3 free public Neutron RPC endpoints measured, 114 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Stake&Relax: 114 ms (p99 380 ms, success 100.0%, sample 4317.75)
2. Polkachu: 128 ms (p99 247 ms, success 100.0%, sample 4318.75)
3. LavenderFive: 169 ms (p99 680 ms, success 99.7%, sample 4316.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 3 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 2 free public World Chain RPC endpoints measured above the 50 % success floor (3 listed), 9 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. World Chain: 9 ms (p99 22 ms, success 100.0%, sample 4320.75)
2. BlockVectra: 112 ms (p99 333 ms, success 100.0%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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.

## 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 5 free public Ink RPC endpoints measured, 71 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Quicknode: 71 ms (p99 106 ms, success 100.0%, sample 4319.75)
2. Gelato: 95 ms (p99 310 ms, success 100.0%, sample 4317.75)
3. Tenderly Gateway: 105 ms (p99 133 ms, success 100.0%, sample 4321.75)
4. BlockVectra: 112 ms (p99 334 ms, success 99.9%, sample 4319.75)
5. dRPC: 207 ms (p99 484 ms, success 99.8%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 5 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 223 ms, success 100.0%, sample 4320.75)
2. PublicNode: 84 ms (p99 240 ms, success 100.0%, sample 4319.75)
3. dRPC: 196 ms (p99 661 ms, success 64.4%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: Arbitrum and Base both post the lowest VAA finalization, tied at 1.00 s (p50, 24h) across 10 ranked providers.

**Rankings (p50, 24h):**
1. Arbitrum: 1.00 s (p99 1.98 s, success 100.0%, sample 4.00139)
2. Base: 1.00 s (p99 1.98 s, success 100.0%, sample 2.00069)
3. Sui: 2.89 s (p99 13.30 s, success 100.0%, sample 202.07)
4. Ethereum: 3.50 s (p99 4.97 s, success 100.0%, sample 10.0035)
5. Solana: 3.55 s (p99 9.80 s, success 100.0%, sample 15032.2)
6. Avalanche: 3.59 s (p99 9.83 s, success 100.0%, sample 708.246)
7. BNB Chain: 3.59 s (p99 11.05 s, success 100.0%, sample 10983.8)
8. Polygon: 3.87 s (p99 13.56 s, success 100.0%, sample 2883)
9. Monad: 4.89 s (p99 14.55 s, success 100.0%, sample 27.0094)
10. Ink: 7.76 s (p99 14.47 s, success 100.0%, sample 21.0073)

**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: Mobula leads quote coverage at 96.4% (24h avg) across 4 ranked providers.

**Rankings (Coverage rate, 24h):**
1. Mobula: Coverage rate 96.4%, Tokens probed 24h 729 (success 96.4%, sample 729.253)
2. Jupiter: Coverage rate 86.2%, Tokens probed 24h 1,408 (success 86.2%, sample 1408.49)
3. KyberSwap: Coverage rate 84.8%, Tokens probed 24h 729 (success 84.8%, sample 729.253)
4. ParaSwap: Coverage rate 79.6%, Tokens probed 24h 729 (success 79.6%, sample 729.253)

**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.
- Cohort composition: four of the five are DEX aggregators (Jupiter on Solana, KyberSwap, ParaSwap and Mobula on EVM). Relay is a cross-chain relayer, scored here because it answers the same probe, not because it is an aggregator; the rest of the site types it the same way on bridge-fee and bridge-realized-cost. Read the type beside each name before the rank.
- 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 only, 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). Relay probes all four chains including Solana. Mobula probes the three EVM chains: since 2026-10-08 its API answers every Solana quote with 'Swap quoting is not available for solana:solana', so Solana is left out rather than scored at 0% until it comes back. 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: BNB Chain posts the lowest CCIP delivery at 10.31 s (p50, 24h) across 13 ranked providers.

**Rankings (p50, 24h):**
1. BNB Chain: 10.31 s (p99 2.9 min, success 100.0%, sample 153.053)
2. Avalanche: 16.41 s (p99 4.3 min, success 100.0%, sample 33.0115)
3. Berachain: 22.50 s (p99 29.85 s, success 100.0%, sample 5.00174)
4. Monad: 46.30 s (p99 2.3 min, success 100.0%, sample 75.0261)
5. Solana: 47.08 s (p99 2.0 min, success 100.0%, sample 1012.35)
6. Polygon: 12.5 min (p99 14.9 min, success 100.0%, sample 13.0045)
7. Ethereum: 16.2 min (p99 20.0 min, success 100.0%, sample 327.114)
8. Robinhood Chain: 16.8 min (p99 28.4 min, success 100.0%, sample 31.0108)
9. Arbitrum: 18.1 min (p99 29.6 min, success 100.0%, sample 46.016)
10. Base: 19.5 min (p99 29.9 min, success 100.0%, sample 213.074)
11. Mantle: 20.0 min (p99 29.8 min, success 100.0%, sample 2.00069)
12. Ink: 22.7 min (p99 29.9 min, success 100.0%, sample 16.0056)
13. Optimism: 23.6 min (p99 29.9 min, success 100.0%, sample 9.00313)

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

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

- Category: Bridges
- Metric: LayerZero delivery (ms)
- Page: https://openchainbench.com/benchmarks/layerzero-message-latency
- JSON: https://openchainbench.com/api/stat/layerzero-message-latency
- Status: live
- Headline: Robinhood Chain posts the lowest layerZero delivery at 15.32 s (p50, 24h) across 17 ranked providers.

**Rankings (p50, 24h):**
1. Robinhood Chain: 15.32 s (p99 2.6 min, success 100.0%, sample 378.132)
2. Base: 17.49 s (p99 1.8 min, success 100.0%, sample 1632.57)
3. Celo: 17.81 s (p99 1.6 min, success 100.0%, sample 71.0248)
4. BNB Chain: 20.18 s (p99 1.9 min, success 100.0%, sample 988.343)
5. Arbitrum: 24.34 s (p99 28.0 min, success 100.0%, sample 1210.42)
6. Solana: 24.35 s (p99 1.9 min, success 100.0%, sample 574.199)
7. Sui: 25.00 s (p99 1.8 min, success 100.0%, sample 18.0063)
8. Avalanche: 26.68 s (p99 2.7 min, success 100.0%, sample 153.053)
9. Monad: 40.38 s (p99 19.7 min, success 100.0%, sample 81.0283)
10. Unichain: 41.05 s (p99 29.0 min, success 100.0%, sample 40.014)
11. Ink: 41.25 s (p99 2.0 min, success 100.0%, sample 22.0077)
12. Mantle: 55.00 s (p99 2.7 min, success 100.0%, sample 30.0105)
13. Optimism: 1.2 min (p99 38.4 min, success 100.0%, sample 563.196)
14. Polygon: 1.4 min (p99 13.7 min, success 100.0%, sample 238.083)
15. Scroll: 2.6 min (p99 4.9 min, success 100.0%, sample 28.0098)
16. Linea: 2.8 min (p99 8.8 min, success 100.0%, sample 25.0087)
17. Ethereum: 4.2 min (p99 19.5 min, success 100.0%, sample 1095.38)

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

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

- Category: Bridges
- Metric: Axelar GMP delivery (ms)
- Page: https://openchainbench.com/benchmarks/axelar-gmp-latency
- JSON: https://openchainbench.com/api/stat/axelar-gmp-latency
- Status: live
- Headline: BNB Chain posts the lowest axelar GMP delivery at 36.82 s (p50, 24h) across 11 ranked providers.

**Rankings (p50, 24h):**
1. BNB Chain: 36.82 s (p99 4.1 min, success 100.0%, sample 46.016)
2. Osmosis: 44.66 s (p99 15.5 min, success 100.0%, sample 179.062)
3. Polygon: 45.00 s (p99 2.0 min, success 100.0%, sample 16.0056)
4. Avalanche: 46.50 s (p99 2.0 min, success 100.0%, sample 19.0066)
5. Ethereum: 16.7 min (p99 23.7 min, success 100.0%, sample 63.0219)
6. Arbitrum: 21.0 min (p99 29.8 min, success 100.0%, sample 18.0063)
7. Optimism: 25.0 min (p99 29.9 min, success 100.0%, sample 4.00139)
8. Base: 25.2 min (p99 37.2 min, success 100.0%, sample 28.0097)
9. Celo: 26.3 min (p99 39.5 min, success 100.0%, sample 5.00174)
10. Linea: 45.0 min (p99 49.9 min, success 100.0%, sample 1.00035)
11. Scroll: 67.5 min (p99 74.8 min, success 100.0%, sample 1.00035)

**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, 54 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Sei Labs: 54 ms (p99 112 ms, success 100.0%, sample 4319.75)
2. Stakeme: 208 ms (p99 731 ms, success 99.7%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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 above the 50 % success floor (3 listed), 138 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Mode Labs: 138 ms (p99 256 ms, success 100.0%, sample 4320.75)
2. dRPC: 444 ms (p99 711 ms, success 60.6%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 3 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, 105 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tenderly Gateway: 105 ms (p99 132 ms, success 100.0%, sample 4318.75)
2. Sky Mavis: 136 ms (p99 252 ms, success 100.0%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 119 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Immutable: 119 ms (p99 141 ms, success 100.0%, sample 4321.75)
2. Tenderly Gateway: 124 ms (p99 156 ms, success 100.0%, sample 4318.75)
3. dRPC: 239 ms (p99 524 ms, success 97.9%, sample 4321.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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.42 s (p50, 24h) across 1 ranked venue.

**Rankings (p50, 24h):**
1. Polymarket: 1.42 s (p99 9.54 s, success 50.0%, sample 23.008)

**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 26 ranked validators.

**Rankings (p50, 24h):**
1. infinitefield.xyz: 2.24% (p99 2.24%, success 100.0%, sample 1013860000)
2. HyperStake: 2.24% (p99 2.24%, success 100.0%, sample 377319000)
3. CMI: 2.24% (p99 2.24%, success 100.0%, sample 536574000)
4. Flowdex: 2.24% (p99 2.24%, success 100.0%, sample 155328000)
5. Hypurrscanning: 2.22% (p99 2.22%, success 100.0%, sample 1360950000)
6. Alphaticks: 2.22% (p99 2.22%, success 100.0%, sample 261652000)
7. Asymmetric Research: 2.21% (p99 2.21%, success 100.0%, sample 214987000)
8. Purrposeful x HyBridge x PiP: 2.20% (p99 2.20%, success 100.0%, sample 423256000)
9. Hyperliquid Strategies x Unit: 2.20% (p99 2.20%, success 100.0%, sample 2287200000)
10. Nansen x HypurrCollective: 2.20% (p99 2.20%, success 100.0%, sample 1261650000)
11. Hyperbeat x P2P x Hypio: 2.20% (p99 2.20%, success 100.0%, sample 250998000)
12. Hyper Foundation 3: 2.17% (p99 2.17%, success 100.0%, sample 3012440000)
13. Hyper Foundation 2: 2.17% (p99 2.17%, success 100.0%, sample 3194510000)
14. Hyper Foundation 1: 2.17% (p99 2.17%, success 100.0%, sample 3063470000)
15. Hyper Foundation 4: 2.17% (p99 2.17%, success 100.0%, sample 2025980000)
16. Hyper Foundation 5: 2.17% (p99 2.17%, success 100.0%, sample 888194000)
17. Hyperdash: 2.17% (p99 2.17%, success 100.0%, sample 572764000)
18. HypurrCorea - Spacebar x DeSpread: 2.17% (p99 2.17%, success 100.0%, sample 482694000)
19. USDT0 x Luganodes: 2.17% (p99 2.17%, success 100.0%, sample 498373000)
20. Enigma - Hypedexer.com X Meria: 2.17% (p99 2.17%, success 100.0%, sample 204453000)
21. Liquid Spirit x Hydromancer x Rekt Gang: 2.16% (p99 2.16%, success 99.7%, sample 248440000)
22. Kinetiq x Hyperion: 2.15% (p99 2.15%, success 100.0%, sample 361200000)
23. ValiDAO: 2.15% (p99 2.15%, success 100.0%, sample 374671000)
24. ASXN: 2.13% (p99 2.13%, success 100.0%, sample 502401000)
25. Anchorage By Figment: 2.13% (p99 2.13%, success 100.0%, sample 1524340000)
26. B-Harvest: 2.13% (p99 2.13%, success 100.0%, sample 300322000)

**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 611 (24h) across 23 ranked venues.

**Rankings (p50, 24h):**
1. Aster: 611 (p99 611, success 100.0%, sample 2880)
2. Extended: 338 (p99 338, success 99.8%, sample 2880)
3. Aevo: 239 (p99 239, success 81.0%, sample 2880)
4. Lighter: 210 (p99 210, success 100.0%, sample 2880)
5. GRVT: 194 (p99 194, success 83.3%, sample 2880)
6. Gains: 182 (p99 182, success 100.0%, sample 2880)
7. Hyperliquid: 179 (p99 179, success 100.0%, sample 2880)
8. edgeX: 157 (p99 157, success 83.2%, sample 2880)
9. ApeX Omni: 127 (p99 127, success 80.0%, sample 2880)
10. Kalshi: 125 (p99 125, success 79.9%, sample 2880)
11. trade.xyz: 123 (p99 123, success 80.0%, sample 2880)
12. Polymarket: 90 (p99 90, success 80.0%, sample 2880)
13. Vest: 88 (p99 88, success 75.0%, sample 2880)
14. Ostium: 83 (p99 83, success 60.0%, sample 2880)
15. Ondo Perps: 81 (p99 81, success 79.8%, sample 2880)
16. Pacifica: 80 (p99 80, success 83.3%, sample 2880)
17. Nado: 72 (p99 73, success 82.9%, sample 2880)
18. Lighter RH: 72 (p99 72, success 80.0%, sample 2880)
19. Paradex: 66 (p99 66, success 100.0%, sample 2880)
20. dYdX v4: 57 (p99 57, success 100.0%, sample 2880)
21. StandX: 13 (p99 13, success 80.0%, sample 2880)
22. Jupiter Perps: 3 (p99 3, success 80.0%, sample 2880)
23. Papertrade: 2 (p99 2, 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: GET backend-arbitrum.gains.trade/trading-variables, every pair minus the ones whose max leverage override is 1 (0.001x), which is how Gains delists a pair without removing it. Covers crypto, forex, stocks, indices and commodities. Until 2026-10-12 this row read Mobula's perp pairs catalog, which listed 355 Gains pairs where 178 can be opened today, and which Mobula has since deprecated.
- Nova: the same read against Nova's own trading variables, measured but carried unranked. Nova runs the same gTrade software as Gains and serves the identical 493-pair registry. Gains marks 315 of those pairs with the 0.001x delisting override and counts 178; Nova marks none, and 40 of its pairs carry no override entry at all. Its 493 is the catalog it inherited, not markets confirmed openable, so it is a different measurement from every other row (read 2026-10-22).
- 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 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: 1.000x (p99 1.000x, success 98.7%, sample 2880)
3. edgeX: 1.129x (p99 1.081x, success 100.0%, sample 2880)
4. Aster: 1.177x (p99 1.005x, success 100.0%, sample 2880)
5. Hyperliquid: 1.267x (p99 1.014x, success 100.0%, sample 2880)
6. dYdX v4: 1.579x (p99 1.012x, success 100.0%, sample 2880)
7. Extended: 1.869x (p99 1.012x, success 100.0%, sample 2880)
8. Lighter: 6.16x (p99 1.373x, success 100.0%, sample 2830)

**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: Hyperliquid posts the lowest mark price deviation at 0.061% (p50, 24h) across 6 ranked venues.

**Rankings (p50, 24h):**
1. Hyperliquid: 0.061% (p99 0.16%, success 98.4%, sample 2880)
2. Lighter: 0.062% (p99 0.11%, success 99.9%, sample 2880)
3. Gains: 0.14% (p99 0.24%, success 100.0%, sample 2880)
4. dYdX v4: 0.14% (p99 0.27%, success 98.7%, sample 2880)
5. GMX: 0.14% (p99 0.25%, success 99.9%, sample 2880)
6. Paradex: 0.20% (p99 0.35%, 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,816 (24h) across 6 ranked venues.

**Rankings (p50, 24h):**
1. Gains: 1,816 (p99 1,816, success 100.0%, sample 2880)
2. dYdX v4: 1,147 (p99 1,147, success 100.0%, sample 2880)
3. Paradex: 1,147 (p99 1,147, success 100.0%, sample 2880)
4. Hyperliquid: 1,116 (p99 1,116, success 100.0%, sample 2880)
5. GMX: 500 (p99 500, success 100.0%, sample 2880)
6. Lighter: 5 (p99 5, 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 3 free public Kava RPC endpoints measured, 51 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 51 ms (p99 132 ms, success 100.0%, sample 4319.75)
2. PublicNode: 81 ms (p99 303 ms, success 100.0%, sample 4317.75)
3. dRPC: 217 ms (p99 483 ms, success 99.3%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 3 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: Conduit has the lowest median latency of the 3 free public Zora RPC endpoints measured, 139 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Conduit: 139 ms (p99 181 ms, success 100.0%, sample 4320.75)
2. Zora Network: 139 ms (p99 252 ms, success 100.0%, sample 4319.75)
3. dRPC: 279 ms (p99 469 ms, success 98.9%, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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 167 (24h) across 16 ranked venues.

**Rankings (p50, 24h):**
1. Hyperliquid: 167 (p99 167, success 100.0%, sample 2880)
2. Extended: 137 (p99 137, success 100.0%, sample 2880)
3. Aster: 125 (p99 125, success 100.0%, sample 2880)
4. trade.xyz: 123 (p99 123, success 100.0%, sample 2880)
5. Kalshi: 106 (p99 106, success 100.0%, sample 2880)
6. Lighter: 87 (p99 87, success 100.0%, sample 2880)
7. Vest: 75 (p99 75, success 100.0%, sample 2880)
8. Ostium: 74 (p99 74, success 100.0%, sample 2880)
9. Ondo Perps: 67 (p99 67, success 100.0%, sample 2880)
10. Gains: 59 (p99 59, success 100.0%, sample 2880)
11. Lighter RH: 47 (p99 47, success 100.0%, sample 2880)
12. ApeX Omni: 40 (p99 40, success 100.0%, sample 2880)
13. Paradex: 23 (p99 23, success 100.0%, sample 2880)
14. GMX: 8 (p99 8, success 100.0%, sample 2880)
15. dYdX v4: 0 (p99 0, success 100.0%, sample 2880)
16. Papertrade: 0 (p99 0, 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: the pair groups of its Arbitrum trading variables (forex, forex-minor and forex-exotic are forex; stocks-1 to 3 are stocks; indices; commodities-1 and 2; the three crypto groups are crypto), delisted pairs (max leverage 0.001x) left out. Read from Mobula's perp catalog until Mobula deprecated it on 2026-10-12.
- Lighter publishes no class, so its symbols take the class another venue tags them with, then the fixed tables; a symbol no venue tags counts as crypto, so a pre-IPO synthetic only Lighter lists is undercounted, never invented. Read from Mobula's perp catalog until 2026-10-12.
- 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, 147 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Abstract Foundation: 147 ms (p99 575 ms, success 100.0%, sample 4319.75)
2. dRPC: 261 ms (p99 550 ms, success 98.9%, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: ApeChain has the lowest median latency of the 2 free public ApeChain RPC endpoints measured, 163 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. ApeChain: 163 ms (p99 342 ms, success 100.0%, sample 4317.75)
2. dRPC: 267 ms (p99 527 ms, success 98.9%, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 2 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: Tenderly has the lowest median latency of the 2 free public Lisk RPC endpoints measured, 152 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tenderly: 152 ms (p99 170 ms, success 99.1%, sample 4319.75)
2. dRPC: 295 ms (p99 748 ms, success 79.8%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 2 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, 124 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Cyber Network: 124 ms (p99 142 ms, success 100.0%, sample 4320.75)
2. AltLayer: 149 ms (p99 219 ms, success 100.0%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 140 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Rootstock Foundation: 140 ms (p99 593 ms, success 100.0%, sample 4318.75)
2. dRPC: 270 ms (p99 759 ms, success 98.3%, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 79 ms (p99 248 ms, success 100.0%, sample 4320.75)
2. Metis: 129 ms (p99 903 ms, success 99.1%, sample 4318.75)
3. dRPC: 145 ms (p99 266 ms, success 99.5%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: dRPC has the lowest median latency of the 2 free public Manta Pacific RPC endpoints measured above the 50 % success floor (3 listed), 152 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 152 ms (p99 267 ms, success 99.2%, sample 4321.75)
2. Manta Network: 157 ms (p99 275 ms, success 99.9%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 3 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: Story Foundation has the lowest median latency of the 3 free public Story RPC endpoints measured, 36 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Story Foundation: 36 ms (p99 122 ms, success 100.0%, sample 4319.75)
2. PublicNode: 86 ms (p99 344 ms, success 100.0%, sample 4318.75)
3. Stakely: 161 ms (p99 1.50 s, success 99.6%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 3 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, 59 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Quicknode: 59 ms (p99 64 ms, success 100.0%, sample 4320.75)
2. dRPC: 152 ms (p99 296 ms, success 99.2%, sample 4316.75)
3. Morph: 181 ms (p99 258 ms, success 99.7%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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 has the lowest median latency of the 2 free public Moonriver RPC endpoints measured, 70 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 70 ms (p99 7.19 s, success 80.5%, sample 4317.75)
2. dRPC: 207 ms (p99 1.54 s, success 60.5%, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 2 no-key endpoints. Cohort rebuilt 2026-10-09: the Foundation endpoint and PublicNode dropped, dRPC and UnitedBloc restored after both answered on the current head on 10 of 10 probes.

## 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, 106 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Hemi Labs: 106 ms (p99 401 ms, success 100.0%, sample 4319.75)
2. dRPC: 129 ms (p99 219 ms, success 99.3%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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.

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

**Rankings (p50, 24h):**
1. dRPC: 899 ms (p99 2.00 s, success 63.7%, sample 4316.75)
2. Polygon zkEVM: 999 ms (p99 4.35 s, success 80.8%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 83 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 83 ms (p99 303 ms, success 100.0%, sample 4319.75)
2. dRPC: 203 ms (p99 472 ms, success 99.0%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 120 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 120 ms (p99 210 ms, success 99.1%, sample 4321.75)
2. X Layer: 152 ms (p99 366 ms, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 69 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 69 ms (p99 232 ms, success 100.0%, sample 4320.75)
2. dRPC: 140 ms (p99 227 ms, success 99.1%, sample 4319.75)
3. Flare Foundation: 149 ms (p99 581 ms, success 99.9%, sample 4318.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 88 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 88 ms (p99 202 ms, success 100.0%, sample 4319.75)
2. Core DAO: 128 ms (p99 220 ms, success 100.0%, sample 4320.75)
3. dRPC: 155 ms (p99 263 ms, success 99.0%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 216 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Fuse Foundation: 216 ms (p99 475 ms, success 100.0%, sample 4316.75)
2. dRPC: 280 ms (p99 569 ms, success 99.6%, sample 4316.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: Ostium leads markets per $M TVL at 43 (24h at the average daily rate) across 12 ranked venues.

**Rankings (p50, 24h):**
1. Ostium: 43 (p99 43, success 60.0%, sample 2880)
2. Gains: 30 (p99 30, success 100.0%, sample 2880)
3. Aevo: 17 (p99 17, success 81.0%, sample 2880)
4. GRVT: 5 (p99 5, success 83.3%, sample 2880)
5. Extended: 3 (p99 3, success 99.8%, sample 2880)
6. Paradex: 3 (p99 3, success 100.0%, sample 2880)
7. edgeX: 3 (p99 3, success 83.2%, sample 2880)
8. Aster: 0.841 (p99 0.841, success 100.0%, sample 2880)
9. dYdX v4: 0.799 (p99 0.799, success 100.0%, sample 2880)
10. Lighter: 0.316 (p99 0.316, success 100.0%, sample 2880)
11. Papertrade: 0.097 (p99 0.097, success 80.0%, sample 2880)
12. Hyperliquid: 0.023 (p99 0.023, 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: its Arbitrum trading variables minus delisted pairs. 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.
- Floor. A venue ranks only with at least $1M of trading TVL. The metric divides by TVL, so a small vault inflates the ratio: one market on $120k of backing reads 8.4 and ranks fourth, above four venues carrying 66 to 334 markets, which inverts what a high number means here. The threshold sits in a gap in the data: on 2026-10-22 the smallest ranked vault was $3.95M, so no row in the field moves.
- 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, 57 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 57 ms (p99 104 ms, success 100.0%, sample 4320.75)
2. Glif: 117 ms (p99 373 ms, success 100.0%, sample 4321.75)
3. dRPC: 287 ms (p99 644 ms, success 99.9%, sample 4317.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.
- 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 has the lowest median latency of the 2 free public Aurora RPC endpoints measured, 126 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Aurora Labs: 126 ms (p99 587 ms, success 99.7%, sample 4319.75)
2. dRPC: 244 ms (p99 607 ms, success 99.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.
- 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: 2 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.

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

**Rankings (p50, 24h):**
1. B² Network Official: 265 ms (p99 548 ms, success 100.0%, sample 4317.75)
2. dRPC: 362 ms (p99 789 ms, success 98.9%, 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.
- 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, 89 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 89 ms (p99 354 ms, success 100.0%, sample 4318.75)
2. Polkachu: 126 ms (p99 242 ms, success 98.5%, sample 4319.75)
3. LavenderFive: 169 ms (p99 586 ms, success 99.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":"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, 84 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 84 ms (p99 259 ms, success 100.0%, sample 4319.75)
2. Polkachu: 128 ms (p99 247 ms, success 100.0%, sample 4317.75)
3. LavenderFive: 169 ms (p99 588 ms, success 100.0%, sample 4317.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":"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: BlockVectra has the lowest median latency of the 3 free public Boba Network RPC endpoints measured, 112 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. BlockVectra: 112 ms (p99 330 ms, success 100.0%, sample 4319.75)
2. Boba Foundation: 114 ms (p99 549 ms, success 100.0%, sample 4318.75)
3. dRPC: 198 ms (p99 527 ms, success 75.5%, 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.
- 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: 3 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, 79 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 79 ms (p99 200 ms, success 100.0%, sample 4320.75)
2. XDC eRPC: 113 ms (p99 358 ms, success 98.0%, sample 4316.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.
- 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 has the lowest median latency of the 3 free public Astar Network RPC endpoints measured, 186 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 186 ms (p99 7.70 s, success 60.1%, sample 4316.75)
2. Astar: 312 ms (p99 6.80 s, success 97.7%, sample 4320.75)
3. dRPC: 477 ms (p99 1.92 s, success 80.9%, sample 4318.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.
- 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: 3 no-key public-read endpoints live today, each listed with its URL in the endpoints table on this page. PublicNode returned 404 and was removed.

## 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 143 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Oasis Foundation: 143 ms (p99 208 ms, 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.
- 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 148 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Oasis Foundation: 148 ms (p99 687 ms, success 99.9%, sample 4316.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.
- 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, 127 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Conflux Global: 127 ms (p99 913 ms, success 99.7%, sample 4318.75)
2. Conflux Foundation: 474 ms (p99 1.03 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.
- 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 Foundation has the lowest median latency of the 2 free public IoTeX RPC endpoints measured, 132 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. IoTeX Foundation: 132 ms (p99 196 ms, success 100.0%, sample 4320.75)
2. IoTeX Mirror: 137 ms (p99 267 ms, success 99.6%, sample 4321.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.
- 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: 2 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 has the lowest median latency of the 2 free public Harmony ONE RPC endpoints measured, 129 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Harmony S0: 129 ms (p99 405 ms, success 73.4%, sample 4317.85)
2. dRPC: 186 ms (p99 453 ms, success 72.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.
- 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: 2 no-key endpoints (Harmony S0).

## 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 45 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Vana Foundation: 45 ms (p99 130 ms, success 100.0%, sample 4318.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.
- 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).

## 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 156 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Reya Foundation: 156 ms (p99 199 ms, success 100.0%, sample 4317.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.
- 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, 85 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 85 ms (p99 277 ms, success 100.0%, sample 4318.75)
2. Polkachu: 126 ms (p99 247 ms, success 100.0%, sample 4319.75)
3. Ecostake: 165 ms (p99 393 ms, success 99.9%, sample 4315.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":"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
- 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":"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: 1 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, 83 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 83 ms (p99 262 ms, success 100.0%, sample 4318.75)
2. Polkachu: 126 ms (p99 225 ms, success 100.0%, sample 4316.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":"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.

## 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 248 ms, success 100.0%, sample 4319.75)
2. LavenderFive: 167 ms (p99 730 ms, success 100.0%, sample 4317.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":"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, 127 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 127 ms (p99 245 ms, success 100.0%, sample 4314.75)
2. Persistence Foundation: 166 ms (p99 1.30 s, success 99.9%, sample 4318.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":"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, 84 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 84 ms (p99 300 ms, success 100.0%, sample 4319.75)
2. Coreum Foundation: 275 ms (p99 365 ms, 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":"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 125 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 125 ms (p99 240 ms, success 100.0%, sample 4315.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":"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: Archway Foundation has the lowest median latency of the 2 free public Archway RPC endpoints measured, 93 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Archway Foundation: 93 ms (p99 104 ms, success 99.7%, sample 4319.75)
2. LavenderFive: 142 ms (p99 590 ms, success 99.9%, 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":"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, 89 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Nibiru Foundation: 89 ms (p99 281 ms, success 100.0%, sample 4319.75)
2. Polkachu: 127 ms (p99 246 ms, success 100.0%, sample 4317.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":"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, 85 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 85 ms (p99 311 ms, success 100.0%, sample 4318.75)
2. Polkachu: 127 ms (p99 245 ms, success 99.9%, sample 4318.75)
3. LavenderFive: 138 ms (p99 729 ms, success 99.2%, sample 4319.76)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<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: ECO Stake has the lowest median latency of the 2 free public Regen Network RPC endpoints measured, 122 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. ECO Stake: 122 ms (p99 195 ms, success 100.0%, sample 4318.75)
2. Polkachu: 125 ms (p99 244 ms, 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":"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: 2 no-key endpoints.

## 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, 112 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Fantom Foundation: 112 ms (p99 137 ms, success 100.0%, sample 4319.75)
2. dRPC: 147 ms (p99 219 ms, success 99.7%, sample 4316.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.
- 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, Thirdweb).

## 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, 50 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 50 ms (p99 1.23 s, success 100.0%, sample 4319.75)
2. PublicNode: 89 ms (p99 303 ms, success 100.0%, sample 4319.75)
3. dRPC: 432 ms (p99 647 ms, success 98.2%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<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: Dwellir has the lowest median latency of the 2 free public Hydration RPC endpoints measured, 156 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Dwellir: 156 ms (p99 393 ms, success 100.0%, sample 4319.75)
2. Hydration: 160 ms (p99 481 ms, success 99.8%, sample 4318.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":"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, 86 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 86 ms (p99 363 ms, success 100.0%, sample 4319.75)
2. HAQQ Foundation: 118 ms (p99 362 ms, success 99.7%, sample 4319.75)
3. dRPC: 227 ms (p99 564 ms, success 99.4%, sample 4317.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.
- 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 is the only free public Etherlink RPC endpoint measured, at 27 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Etherlink Foundation: 27 ms (p99 121 ms, 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.
- 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: 1 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, 75 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ankr: 75 ms (p99 107 ms, success 100.0%, sample 4321.75)
2. PublicNode: 84 ms (p99 199 ms, success 100.0%, sample 4319.75)
3. Chiliz Foundation: 110 ms (p99 400 ms, success 100.0%, sample 4317.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.
- 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, 131 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 131 ms (p99 252 ms, success 98.9%, sample 4320.75)
2. WeMade: 171 ms (p99 526 ms, success 100.0%, sample 4318.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.
- 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 has the lowest median latency of the 2 free public Songbird RPC endpoints measured, 148 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Flare Foundation: 148 ms (p99 586 ms, success 99.6%, sample 4320.75)
2. AU: 199 ms (p99 677 ms, 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.
- 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: 2 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, 160 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Cronos (Crypto.com): 160 ms (p99 415 ms, success 100.0%, sample 4319.75)
2. dRPC: 275 ms (p99 584 ms, success 92.4%, sample 4317.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.
- 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: ETC Desktop has the lowest median latency of the 3 free public Ethereum Classic RPC endpoints measured, 118 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. ETC Desktop: 118 ms (p99 568 ms, success 100.0%, sample 4320.75)
2. ETC Network: 148 ms (p99 316 ms, success 71.2%, sample 4321.95)
3. dRPC: 272 ms (p99 675 ms, success 99.6%, sample 4316.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.
- 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: 3 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 165 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 165 ms (p99 455 ms, success 99.8%, sample 4318.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.
- 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, 78 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 78 ms (p99 209 ms, success 100.0%, sample 4318.75)
2. G4MM4: 116 ms (p99 388 ms, success 100.0%, sample 4317.75)
3. PulseChain Foundation: 118 ms (p99 341 ms, success 100.0%, sample 4316.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.
- 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
- 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":"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: 0 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, 87 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 87 ms (p99 290 ms, success 100.0%, sample 4320.75)
2. Orai Foundation: 131 ms (p99 273 ms, 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: 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, 51 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OnFinality: 51 ms (p99 1.75 s, success 100.0%, sample 4319.75)
2. PublicNode: 78 ms (p99 161 ms, success 100.0%, sample 4317.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":"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.

## Launchpad leaderboard: pump.fun vs Pons Family vs Stonk.fun vs long.xyz

- Category: Trading
- Metric: 24h volume (usd)
- Page: https://openchainbench.com/benchmarks/launchpad-wars
- JSON: https://openchainbench.com/api/stat/launchpad-wars
- Status: live
- Headline: pump.fun leads 24h volume at $273.65M (24h) across 7 ranked launchpads.

**Rankings (p50, 24h):**
1. pump.fun: $273.65M (p99 $273.65M, success 100.0%, sample 11565409)
2. Pons Family: $14.91M (p99 $14.91M, success 100.0%, sample 140706)
3. Stonk.fun: $6.86M (p99 $6.86M, success 100.0%, sample 149010)
4. long.xyz: $3.36M (p99 $3.36M, success 100.0%, sample 21438)
5. LetsBonk: $2.44M (p99 $2.44M, success 100.0%, sample 33049)
6. ArgusPad: $104.5K (p99 $104.5K, success 100.0%, sample 2063)
7. Flap: $54.1K (p99 $54.1K, success 100.0%, sample 2422)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. One read of /launchpads per cycle, taking the window=1d totals, so every figure is a single day's and never a window sum.
- What is counted: trading volume on the tokens that launched on that pad, whoever routed the trade. A swap executed through Axiom on a pump.fun token counts here for pump.fun and on bench 267 for Axiom. The two benches are not double counting; they are answering different questions.
- Known divergence from other indexers, unresolved and stated rather than smoothed. On 2026-10-07 this source reported pump.fun at $688.4M for the day against $185.0M from DeFiLlama and $188.4M from Mobula, two indexers that share no code and landed 1.8% apart. On `flap` the comparison runs the other way, $0.5M here against $21.4M from Mobula.
- Why that divergence is not a counting convention: at chain level this source reads 2.08x DeFiLlama on Solana, 1.16x on Base and 0.27x on HyperEVM. The three differ in which venues they index, not in whether they count both legs of a swap.
- Single source by decision. Every bench on the /trading-apps hub reads tehcscreener so that no two columns on one page can disagree about the same product. The cost is that nothing here is cross-checked against a second indexer, and the pump.fun figure above is what that costs.
- Chains: Solana and Robinhood Chain as tabs, plus an all-chains total. Volume adds up across chains, so that total is a sum rather than a headline slice. Arc is measured and counted in the total but gets no tab, because one pad on a chain is a list rather than a comparison.
- Stale source: a pad the source stops returning, or one with no volume on the day, has its gauges deleted and reads unresponsive. An old figure is never republished as current.
- Not the launchpad's own revenue: this is volume on its tokens, not fees it collected. The revenue endpoint this source exposes covers pump.fun only and is 987 of 988 days Dune-seeded, so it is not read here.

## Trading terminal leaderboard: what GMGN, Axiom, Fomo and Terminal route and what they charge

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

**Rankings (Volume, 24h):**
1. Axiom: Volume $39.83M (success 100.0%, sample 1036394)
2. pump.fun: Volume $32.20M (success 100.0%, sample 1126755)
3. Fomo: Volume $30.11M (success 100.0%, sample 538918)
4. GMGN: Volume $16.29M (success 100.0%, sample 321996)
5. Terminal: Volume $7.92M (success 100.0%, sample 171873)
6. Trojan: Volume $1.14M (success 100.0%, sample 27880)
7. Photon: Volume $379.5K (success 100.0%, sample 12125)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. The single source behind every bench on the /trading-apps hub, so no two columns on one page can disagree about the same product.
- Volume: what the terminal routed through its own interface on the selected chain, or summed across every chain on the all-chains tab. Not volume on the tokens it trades, which is bench 200.
- Fee revenue: what this source reports as fees. It is demonstrably more than the terminal's own commission, measured against published fee schedules: Trojan advertises 0.9% and this source reads 1.12%. The exact composition is not documented by the source.
- Windows are sums over days, never averages of daily rates. Volume, fees and transactions add over days the same way they add over chains, and the take rate built on them is volume-weighted by construction: total fees over the volume of the days whose fees could be measured.
- A day a platform reports exactly zero fees while charging on another day or chain is treated as a gap, not a price, and leaves the ratio entirely, numerator and denominator together. A platform reporting nothing anywhere is uniformly free and keeps a real zero.
- Two gates sit between a reported fee and a published take rate. A day whose fee exceeds 10% of its own volume leaves the ratio: every measured rate here falls between 0.39% and 2.2%, so a day far above that is a fee attributed to the wrong denominator, not a terminal keeping a tenth of the ticket. The all-chains rate also needs half the platform's volume on measurable days, because a rate read off a sliver is not the rate of the whole. Volume and transactions survive it.
- Single source by decision, and this is what it costs: nothing here is cross-checked against a second indexer. On 2026-10-07 this source read pump.fun 2.2x above DeFiLlama on app volume and 3.7x above both DeFiLlama and Mobula on launchpad volume, while agreeing with DeFiLlama within 30% on six other platforms. The figures published are this source's.
- Latest complete day: the source publishes daily and its latest day is normally yesterday. A terminal with no activity on the selected chain reads unresponsive rather than carrying its last live day forward.

## 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 28142)
2. Kraken: Rating 4.74x (success 100.0%, sample 36503)
3. Bybit: Rating 4.69x (success 100.0%, sample 46930)
4. Coinbase: Rating 4.68x (success 100.0%, sample 1798077)
5. Crypto.com: Rating 4.66x (success 100.0%, sample 336822)
6. PumpFun: Rating 4.53x (success 100.0%, sample 4857)
7. GMGN: Rating 4.33x (success 100.0%, sample 198)
8. Robinhood: Rating 4.30x (success 100.0%, sample 4923636)
9. Moonshot: Rating 4.23x (success 100.0%, sample 28766)
10. Invo: Rating 4.21x (success 100.0%, sample 502)
11. Binance.US: Rating 4.21x (success 100.0%, sample 111078)

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

## Memecoin terminal take rates: what Terminal, Trojan, GMGN and pump.fun keep

- Category: Trading
- Metric: Observed take rate (pct)
- Page: https://openchainbench.com/benchmarks/memecoin-platforms
- JSON: https://openchainbench.com/api/stat/memecoin-platforms
- Status: live
- Headline: pump.fun posts the lowest observed take rate at 0.34% (24h avg) across 8 ranked terminals.

**Rankings (p50, 24h):**
1. pump.fun: 0.34% (p99 0.34%, success 100.0%, sample 100204)
2. Fomo: 0.55% (p99 0.55%, success 100.0%, sample 164194)
3. Axiom: 0.88% (p99 0.88%, success 100.0%, sample 342426)
4. Maestro: 0.93% (p99 0.93%, success 100.0%, sample 6988.85)
5. Photon: 1.04% (p99 1.04%, success 100.0%, sample 3951.03)
6. GMGN: 1.04% (p99 1.04%, success 100.0%, sample 169944)
7. Trojan: 1.10% (p99 1.10%, success 100.0%, sample 12570.6)
8. Terminal: 1.28% (p99 1.28%, success 100.0%, sample 101621)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. The harness reads /bots over the full history for the roster and /bots/{bot} for each terminal's per-chain daily series, and publishes one day: the latest the source names.
- The ratio: that day's fee revenue in USD divided by that day's routed volume in USD, times 100, both read from the same row of the same series. A lower bound on what the terminal charges, because waivers, rebates and promotions reduce what it keeps without changing its schedule.
- Zeros are not ranked unless they are consistent, guarded at two levels. Per chain: when no terminal on a chain reports any fee, the column has failed and no take rate publishes there. Per cell: a terminal reporting fees on one chain and exactly zero on another, on material volume, has that cell withheld, because a waived fee and an unmeasured one look identical here. Axiom charges 0.92% on Solana and reported $0.00 on $29.8M of Robinhood volume.
- Removed on 2026-10-07: the fee-paying rate panel, the share of transactions that paid a fee. The current source publishes fee totals, not that share, and nothing here reconstructs it. Approximating it from the fields that do exist would have put a derived number where a measured one used to be.
- Latest complete day, not a rolling 24 hours: the source publishes daily and its latest day is normally yesterday. A terminal with no activity on that day carries no figure and reads unresponsive rather than having its last live day carried forward. BasedBot is the live case, with volume on Robinhood Chain and almost none on Solana.
- Stale source: a day more than 3 whole days behind, or a terminal the source stops returning, has its gauges deleted and reads unresponsive. An old figure is never republished as current, because these gauges are scraped every 60 seconds and read through a 24h window.
- Two freshness layers, because they fail differently: terminal_activity_last_success_unix says the harness is still running, and terminal_activity_health says this terminal and chain published a day inside the window. A harness that runs while its source freezes trips the second, not the first.
- Chains: five are offered as tabs, the ones with at least five terminals and meaningful volume. Arc, HyperEVM, Monad, X Layer and Avalanche are measured but not offered, because one or two terminals on a chain is a list rather than a comparison.
- Not the cost of a swap: this is the terminal's cut only. Slippage, priority fees and pool fees are not in it, and a low take rate can sit on top of a worse total execution. Benches 268 and 279 measure the all-in figure.
- Plausibility ceiling: a cell whose fees exceed 10% of the volume they sit on is withheld, not published. Across this cohort every measured take rate falls between 0.39% and 2.2%, so a cell many times above that is the source attributing a fee to the wrong denominator rather than a terminal keeping a tenth of the ticket. The volume and transaction counts for that cell are still published; only the ratio is dropped.

## Average swap size per trading terminal: who carries the biggest tickets

- Category: Trading
- Metric: Avg swap size (usd)
- Page: https://openchainbench.com/benchmarks/terminal-avg-trade-size
- JSON: https://openchainbench.com/api/stat/terminal-avg-trade-size
- Status: live
- Headline: Maestro leads avg swap size at $132.54 (24h) across 8 ranked terminals.

**Rankings (p50, 24h):**
1. Maestro: $132.54 (p99 $132.54, success 100.0%, sample 5680)
2. Fomo: $55.86 (p99 $55.86, success 100.0%, sample 538918)
3. GMGN: $50.59 (p99 $50.59, success 100.0%, sample 321996)
4. Terminal: $46.09 (p99 $46.09, success 100.0%, sample 171873)
5. Trojan: $40.99 (p99 $40.99, success 100.0%, sample 27880)
6. Axiom: $38.43 (p99 $38.43, success 100.0%, sample 1036394)
7. Photon: $31.30 (p99 $31.30, success 100.0%, sample 12125)
8. pump.fun: $28.57 (p99 $28.57, success 100.0%, sample 1126755)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. The harness reads /bots over the full history for the roster and /bots/{bot} for each terminal's per-chain daily series, and publishes one day: the latest the source names.
- The ratio: that day's routed volume in USD divided by that day's swap transaction count, both read from the same row of the same series. A terminal whose day carries volume but no transaction count, or the reverse, publishes nothing rather than a ratio built on a half-loaded day.
- A mean, not a median: the source publishes daily totals, not a trade-size distribution, so a small number of large tickets moves this figure. It describes the mix of flow a terminal carries, and it is not the size of a typical trade on it.
- Cohort changes on 2026-10-07: Padre, Phantom and Bloom are not covered by the current source and were removed rather than published as zero. pump.fun was added, having been invisible to fee-wallet attribution because it charges no terminal fee.
- Latest complete day, not a rolling 24 hours: the source publishes daily and its latest day is normally yesterday. A terminal with no activity on that day carries no figure and reads unresponsive rather than having its last live day carried forward. BasedBot is the live case, with volume on Robinhood Chain and almost none on Solana.
- Stale source: a day more than 3 whole days behind, or a terminal the source stops returning, has its gauges deleted and reads unresponsive. An old figure is never republished as current, because these gauges are scraped every 60 seconds and read through a 24h window, which would average a frozen figure in as though it had just been measured.
- Two freshness layers, because they fail differently: terminal_activity_last_success_unix says the harness is still running, and terminal_activity_health says this particular terminal and chain published a day inside the window. A harness that runs while its source freezes trips the second, not the first.
- Not scored here: execution quality. A large average ticket says nothing about slippage or fees on that ticket, which benches 268 and 279 measure directly.

## Daily swap transactions per trading terminal: Axiom vs Fomo vs pump.fun vs GMGN

- Category: Trading
- Metric: Swap transactions 24h (count)
- Page: https://openchainbench.com/benchmarks/terminal-swap-transactions
- JSON: https://openchainbench.com/api/stat/terminal-swap-transactions
- Status: live
- Headline: pump.fun leads swap transactions 24h at 1.13M (24h) across 8 ranked terminals.

**Rankings (p50, 24h):**
1. pump.fun: 1.13M (p99 1.13M, success 100.0%, sample 32196300)
2. Axiom: 1.04M (p99 1.04M, success 100.0%, sample 39833500)
3. Fomo: 538.9K (p99 538.9K, success 100.0%, sample 30106000)
4. GMGN: 322.0K (p99 322.0K, success 100.0%, sample 16291300)
5. Terminal: 171.9K (p99 171.9K, success 100.0%, sample 7921920)
6. Trojan: 27.9K (p99 27.9K, success 100.0%, sample 1142710)
7. Photon: 12.1K (p99 12.1K, success 100.0%, sample 379512)
8. Maestro: 5,680 (p99 5,680, success 100.0%, sample 752822)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. The harness reads /bots over the full history for the roster and /bots/{bot} for each terminal's per-chain daily series, and publishes one day: the latest the source names.
- Transactions: the source's swap transaction count for that terminal on the selected chain on the day, or the sum across every chain it serves on the all-chains tab. Transactions add up, so that sum is a real total. A transaction is counted once, so a multi-hop route is one transaction and not one per hop.
- Not wallets: bench 232 counts the distinct wallets behind these transactions from the same source and the same day, and publishes the division as a Swaps per wallet column. A terminal whose users average thirty swaps a day is not serving the same behaviour as one whose users average nine.
- Latest complete day, not a rolling 24 hours: the source publishes daily and its latest day is normally yesterday. A terminal with no activity on that day carries no figure and reads unresponsive rather than having its last live day carried forward. BasedBot is the live case, with volume on Robinhood Chain and almost none on Solana.
- Stale source: a day more than 3 whole days behind, or a terminal the source stops returning, has its gauges deleted and reads unresponsive. An old figure is never republished as current, because these gauges are scraped every 60 seconds and read through a 24h window, which would average a frozen figure in as though it had just been measured.
- Two freshness layers, because they fail differently: terminal_activity_last_success_unix says the harness is still running, and terminal_activity_health says this particular terminal and chain published a day inside the window. A harness that runs while its source freezes trips the second, not the first.
- Scope: seven chains as tabs plus an all-chains total, from the ten the harness measures. The remaining three carry one or two terminals each, which is a list rather than a comparison.
- Not scored here: what those transactions cost. A terminal can lead on transaction count and be the most expensive way to route a swap; benches 268 and 279 measure that.

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

**Rankings (p50, 24h):**
1. PublicNode: 76 ms (p99 244 ms, success 100.0%, sample 4320.75)
2. ZAN: 414 ms (p99 932 ms, success 100.0%, sample 4318.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":"starknet_blockNumber","params":[]}. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 3 no-key endpoints (OnFinality, PublicNode, ZAN).

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

**Rankings (p50, 24h):**
1. OnFinality: 114 ms (p99 963 ms, success 94.5%, sample 4319.75)
2. Lightsail Network: 134 ms (p99 284 ms, success 100.0%, sample 4320.75)
3. SorobanRPC.com: 137 ms (p99 258 ms, success 99.5%, sample 4318.75)
4. Gateway.fm: 142 ms (p99 331 ms, success 100.0%, sample 4320.75)
5. Ankr: 560 ms (p99 3.02 s, success 99.8%, sample 4316.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":"getLatestLedger","params":{}}. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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
- 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":"sui_getLatestCheckpointSequenceNumber","params":[]}. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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: 0 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, 42 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Aptos Labs: 42 ms (p99 133 ms, success 99.4%, sample 4320.8)
2. Aptos Labs (Fullnode): 42 ms (p99 133 ms, success 99.8%, sample 4320.76)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: 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 597 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Ripple: 597 ms (p99 721 ms, success 100.0%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"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'. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, 26 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 26 ms (p99 140 ms, success 88.6%, sample 4318.75)
2. AlgoNode: 68 ms (p99 161 ms, success 100.0%, sample 4320.75)
3. Nodely: 73 ms (p99 228 ms, success 100.0%, sample 4317.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: 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 527 ms, success 88.6%, sample 4318.75)
2. TON Center: 108 ms (p99 323 ms, success 99.9%, sample 4319.75)
3. OnFinality: 182 ms (p99 1.07 s, success 98.1%, sample 4317.75)
4. Uniblock: 338 ms (p99 1.01 s, success 71.1%, sample 4319.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<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, 31 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. FastNEAR: 31 ms (p99 112 ms, success 100.0%, sample 4320.75)
2. dRPC: 107 ms (p99 256 ms, success 98.8%, sample 4320.75)
3. NEAR Foundation: 3.03 s (p99 3.18 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":"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 Foundation has the lowest median latency of the 2 free public Flow RPC endpoints measured, 28 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Flow Foundation: 28 ms (p99 116 ms, success 100.0%, sample 4320.75)
2. Flow Access Node: 28 ms (p99 101 ms, success 100.0%, sample 4318.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: 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).

## 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, 163 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Nervos Foundation: 163 ms (p99 989 ms, success 99.5%, sample 4318.75)
2. CKBapp: 183 ms (p99 530 ms, success 100.0%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<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 4317.75)
2. MultiversX API: 137 ms (p99 428 ms, success 99.9%, sample 4316.75)
3. Elrond API: 151 ms (p99 1.21 s, success 99.2%, sample 4313.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: 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, 93 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. NSPCC: 93 ms (p99 684 ms, success 99.9%, sample 4317.75)
2. NGD: 141 ms (p99 582 ms, success 100.0%, sample 4320.75)
3. NGD (2): 141 ms (p99 586 ms, 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":"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, 87 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. TezBeta: 87 ms (p99 377 ms, success 98.7%, sample 4314.78)
2. SmartPy: 201 ms (p99 4.57 s, success 90.0%, sample 4320.75)
3. TzKT (Baking Bad): 205 ms (p99 515 ms, success 100.0%, sample 4319.75)
4. TCInfra: 265 ms (p99 1.00 s, success 99.8%, sample 4317.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: 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, 117 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. EOS Nation: 117 ms (p99 538 ms, success 100.0%, sample 4318.75)
2. Greymass: 129 ms (p99 472 ms, success 100.0%, sample 4319.75)
3. Aloha EOS: 472 ms (p99 739 ms, success 100.0%, sample 4318.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: 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, 93 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. VeChain Foundation: 93 ms (p99 420 ms, success 100.0%, sample 4320.75)
2. VeThor Node: 93 ms (p99 438 ms, success 100.0%, sample 4320.75)
3. VeChain.energy: 192 ms (p99 881 ms, success 99.6%, sample 4321.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: 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, 136 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Waves.Exchange: 136 ms (p99 368 ms, success 99.7%, sample 4319.75)
2. Waves Foundation: 137 ms (p99 463 ms, success 99.7%, sample 4321.75)
3. Waves Exchange Node: 137 ms (p99 423 ms, success 99.7%, 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: 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, 129 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Greymass: 129 ms (p99 397 ms, success 100.0%, sample 4317.75)
2. EOSUSA: 220 ms (p99 762 ms, success 99.7%, sample 4320.75)
3. WAX Sweden: 283 ms (p99 464 ms, success 100.0%, sample 4318.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: 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.

## 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, 66 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: 66 ms (p99 185 ms, success 99.0%, sample 4317.75)
2. Viction Official: 154 ms (p99 279 ms, success 100.0%, sample 4315.75)
3. Viction RPC2: 166 ms (p99 538 ms, success 100.0%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus avg(quantile_over_time(...)); per-region breakdowns are first-class on this page via the region tabs.
- Payload: {"jsonrpc":"2.0","id":<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 above the 50 % success floor (3 listed), 168 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. OKX Chain Official: 168 ms (p99 433 ms, success 98.1%, sample 4316.75)
2. dRPC: 227 ms (p99 580 ms, success 98.5%, sample 4318.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. 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: 3 endpoints.

## Daily active wallets per trading terminal: Fomo vs Axiom vs pump.fun vs GMGN

- Category: Trading
- Metric: Active wallets 24h (count)
- Page: https://openchainbench.com/benchmarks/trading-platform-wallets
- JSON: https://openchainbench.com/api/stat/trading-platform-wallets
- Status: live
- Headline: Fomo leads active wallets 24h at 49.2K (24h) across 8 ranked terminals.

**Rankings (Active wallets, 24h):**
1. Fomo: Active wallets 49.2K (success 100.0%, sample 538918)
2. Axiom: Active wallets 41.8K (success 100.0%, sample 1036394)
3. pump.fun: Active wallets 38.1K (success 100.0%, sample 1126755)
4. GMGN: Active wallets 9,907 (success 100.0%, sample 321996)
5. Terminal: Active wallets 6,863 (success 100.0%, sample 171873)
6. Trojan: Active wallets 2,141 (success 100.0%, sample 27880)
7. Photon: Active wallets 544 (success 100.0%, sample 12125)
8. Maestro: Active wallets 480 (success 100.0%, sample 5680)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. The harness reads /bots over the full history for the roster and /bots/{bot} for each terminal's per-chain daily series, and publishes one day: the latest the source names.
- Wallets: the source's distinct wallet count for that terminal on that chain on that day. Counted per chain. The source also publishes a cross-chain deduplicated count, but only for 2 of the 9 terminals, so this bench uses the per-chain figure everywhere rather than mixing two definitions in one column.
- Why the counts are not summed across chains: measured on Fomo, the deduplicated cross-chain count is about 0.6 of the sum of its per-chain counts, because a wallet trading on two chains is one wallet. Adding the tabs together would overstate every multi-chain terminal, so each tab is read on its own.
- The two ratios: swaps per wallet is that day's transactions divided by that day's wallets, and volume per wallet is that day's volume divided by the same denominator. Both come from the same row as the count, so all three describe one terminal on one chain on one day.
- Latest complete day, not a rolling 24 hours: the source publishes daily and its latest day is normally yesterday. A terminal with no activity on that day carries no figure and reads unresponsive rather than having its last live day carried forward. BasedBot is the live case, with volume on Robinhood and none on Solana.
- Stale source: a day more than 3 whole days behind, or a terminal the source stops returning, has its gauges deleted and reads unresponsive. An old figure is never republished as current, because these gauges are scraped every 60 seconds and read through a 24h window, which would average a frozen figure in as though it had just been measured.
- Chains: five are offered as tabs, the ones with at least five terminals and meaningful volume. The harness also measures Arc, HyperEVM, Monad, X Layer and Avalanche, which are left off the tab strip because one or two terminals on a chain is a list, not a comparison.
- Includes every wallet: bots, MEV searchers and automated traders all count. Not a human-only metric, and a wallet using two terminals on the same day is counted in both.
- Not scored here: execution quality and cost. A terminal with many wallets is not thereby a cheap one; benches 268 and 279 measure what a swap costs on each.

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

**Rankings (p50, 24h):**
1. Pacifica: $768.64M (p99 $862.80M, success 83.3%, sample 2880)
2. GMX V2: $121.52M (p99 $137.57M, success 60.0%, sample 2880)
3. SynFutures: $113.92M (p99 $172.89M, success 50.0%, sample 2880)
4. Gains: $24.64M (p99 $28.13M, success 100.0%, sample 2880)
5. KiloEx: $12.32M (p99 $13.14M, success 50.0%, sample 2880)
6. Ostium: $3.25M (p99 $3.25M, success 60.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: GMX posts the lowest P/E ratio at 1.994x (24h) across 9 ranked protocols.

**Rankings (p50, 24h):**
1. GMX: 1.994x (p99 1.994x, success 100.0%, sample 2880)
2. GNS: 3.65x (p99 3.65x, success 100.0%, sample 2880)
3. F: 6.68x (p99 6.68x, success 100.0%, sample 2880)
4. JUP: 18.4x (p99 18.4x, success 100.0%, sample 2880)
5. DYDX: 22.7x (p99 22.7x, success 100.0%, sample 2880)
6. APEX: 30.6x (p99 30.6x, success 100.0%, sample 2880)
7. LIT: 32.4x (p99 32.4x, success 100.0%, sample 2880)
8. DRV: 55.3x (p99 55.3x, success 100.0%, sample 2880)
9. HYPE: 59.9x (p99 59.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 3 free public Dogecoin RPC endpoints measured, 92 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 92 ms (p99 194 ms, success 88.4%, sample 4318.75)
2. BlockCypher: 130 ms (p99 636 ms, success 52.8%, sample 4320.75)
3. dRPC: 158 ms (p99 273 ms, success 99.5%, sample 4317.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":"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, 92 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Tatum: 92 ms (p99 172 ms, success 89.2%, sample 4318.75)
2. Blockchair: 148 ms (p99 595 ms, success 98.7%, sample 4319.75)
3. Tatum (Zebra): 160 ms (p99 278 ms, success 88.0%, sample 4318.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 (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, 31 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: p50 31 ms, p90 45 ms, p99 124 ms (success 99.0%, sample 4318.75)
2. PublicNode: p50 76 ms, p90 93 ms, p99 221 ms (success 100.0%, sample 4316.75)
3. bloXroute: p50 104 ms, p90 112 ms, p99 176 ms (success 100.0%, sample 4317.75)
4. Robinhood: p50 127 ms, p90 1.32 s, p99 1.87 s (success 100.0%, sample 4316.75)

**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: Chainstack has the lowest median latency of the 6 private (API-key) Robinhood Chain RPC endpoints measured, 6 ms (p50, 24h, 3 regions).
1. Chainstack: 6 ms (p99 41 ms, success 99.9%, sample 720.125)
2. Quicknode: 7 ms (p99 47 ms, success 100.0%, sample 720.125)
3. Alchemy: 9 ms (p99 52 ms, success 100.0%, sample 720.125)
4. GetBlock: 10 ms (p99 43 ms, success 100.0%, sample 720.125)
5. Dwellir: 10 ms (p99 44 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 112 ms (p99 160 ms, success 100.0%, sample 1080.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/robinhood-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/robinhood-rpc?tier=keyed-cold
- Headline: GetBlock has the lowest median latency of the 6 free public Robinhood Chain RPC endpoints measured, 29 ms (p50, 24h, 3 regions).
1. GetBlock: 29 ms (p99 89 ms, success 100.0%, sample 719.125)
2. Chainstack: 29 ms (p99 83 ms, success 99.6%, sample 719.125)
3. Alchemy: 31 ms (p99 496 ms, success 100.0%, sample 719.125)
4. Quicknode: 38 ms (p99 694 ms, success 100.0%, sample 719.125)
5. Dwellir: 105 ms (p99 344 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 176 ms (p99 444 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/robinhood-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/robinhood-rpc?tier=keyed-heavy
- Headline: Dwellir has the lowest median latency of the 6 free public Robinhood Chain RPC endpoints measured, 13 ms (p50, 24h, 3 regions).
1. Dwellir: 13 ms (p99 22 ms, success 100.0%, sample 43)
2. Alchemy: 13 ms (p99 38 ms, success 100.0%, sample 43)
3. GetBlock: 13 ms (p99 29 ms, success 100.0%, sample 29)
4. Quicknode: 21 ms (p99 80 ms, success 100.0%, sample 43)
5. Chainstack: 34 ms (p99 57 ms, success 100.0%, sample 43)
6. BlockMachine: 129 ms (p99 191 ms, success 100.0%, sample 43)

**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 the same 3 regions; its headline averages us-east and eu-west only, for the GetBlock coverage reason below. 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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): Alchemy, Chainstack, GetBlock, Quicknode, Dwellir and BlockMachine probed on their keyed Robinhood Chain endpoints every 120 seconds from all 3 probe 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: Chainstack: a Global Node on the Growth plan; Alchemy: an enterprise key, not the tier a reader gets; Alchemy states free and paid keys share one routing; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; GetBlock: an endpoint on the Enterprise plan, shared by the two probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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 figure exists for that region: the endpoint is not offered there, which is not a failed or pending measurement. The keyed headline therefore averages us-east and eu-west for every vendor, because averaging a two-region row against three-region rows would compare different populations. Singapore is published per region for the five that answer the Singapore 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.
- 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: BiggestFan Node has the lowest median latency of the 3 free public Bitcoin Cash RPC endpoints measured, 112 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. BiggestFan Node: 112 ms (p99 529 ms, success 99.6%, sample 4319.75)
2. Bitcore (Bitpay): 122 ms (p99 283 ms, success 99.6%, sample 4316.75)
3. Blockchair: 147 ms (p99 174 ms, success 100.0%, sample 4318.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 (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).

## 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, 85 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 85 ms (p99 290 ms, success 100.0%, sample 4316.75)
2. Polkachu: 110 ms (p99 219 ms, success 99.0%, sample 4318.75)
3. LavenderFive: 167 ms (p99 572 ms, success 99.6%, 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: 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, 13 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Acala (RPC-2): 13 ms (p99 183 ms, success 100.0%, sample 4320.75)
2. Acala (RPC-0): 13 ms (p99 188 ms, success 100.0%, sample 4319.75)
3. Dwellir: 327 ms (p99 567 ms, 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":"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
- 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":"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: 0 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, 91 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Validatus: 91 ms (p99 108 ms, success 100.0%, sample 4320.75)
2. Chihuahua: 134 ms (p99 349 ms, success 99.9%, 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: 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, 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, 85 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 85 ms (p99 324 ms, success 100.0%, sample 4319.75)
2. Polkachu: 124 ms (p99 237 ms, success 72.2%, sample 4311.73)
3. Cosmos Directory: 254 ms (p99 450 ms, success 97.9%, 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, 87 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 87 ms (p99 291 ms, success 100.0%, sample 4320.75)
2. Fetch.ai: 169 ms (p99 242 ms, success 100.0%, sample 4318.75)
3. Cosmos Directory: 181 ms (p99 348 ms, success 99.6%, sample 4318.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: 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, 85 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Nodes.Guru: 85 ms (p99 166 ms, success 100.0%, sample 4319.75)
2. Stake And Relax: 113 ms (p99 377 ms, 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: 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, 128 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 128 ms (p99 249 ms, success 100.0%, sample 4317.75)
2. High Stakes: 164 ms (p99 736 ms, success 100.0%, sample 4318.75)
3. Shentu: 361 ms (p99 597 ms, 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: 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: Polkachu has the lowest median latency of the 3 free public MANTRA RPC endpoints measured, 126 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Polkachu: 126 ms (p99 245 ms, success 94.1%, sample 4315.76)
2. ITRocket: 130 ms (p99 198 ms, success 100.0%, sample 4318.75)
3. MANTRA: 144 ms (p99 348 ms, success 99.9%, sample 4318.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: 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, 117 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Band Protocol: 117 ms (p99 273 ms, success 100.0%, sample 4320.75)
2. High Stakes: 204 ms (p99 775 ms, success 100.0%, sample 4317.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: 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: NodeStake has the lowest median latency of the 3 free public cheqd RPC endpoints measured, 89 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. NodeStake: 89 ms (p99 1.44 s, success 97.7%, sample 4318.75)
2. PublicNode: 93 ms (p99 356 ms, success 100.0%, sample 4319.75)
3. cheqd: 168 ms (p99 652 ms, 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: 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, 50 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. ICON Foundation: 50 ms (p99 98 ms, success 100.0%, sample 4320.75)
2. ICON Community: 147 ms (p99 603 ms, success 100.0%, sample 4319.75)
3. iconblockchain.xyz: 159 ms (p99 1.20 s, success 99.7%, sample 4318.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: 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 2 free public Bitcoin RPC endpoints measured, 77 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. PublicNode: 77 ms (p99 193 ms, success 100.0%, sample 4320.75)
2. NOWNodes: 280 ms (p99 780 ms, success 99.9%, sample 4319.75)

**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, 166 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. LUKSO Foundation: 166 ms (p99 757 ms, success 100.0%, sample 4319.75)
2. NOWNodes: 270 ms (p99 488 ms, success 99.9%, sample 4318.75)

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

**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: Mobula posts the lowest slippage vs quote at -$0.00326 (p50, 7d) across 4 ranked providers.

**Rankings (p50, 7d):**
1. Mobula: -$0.00326 (p99 -$0.00326, success 100.0%, sample 0)
2. Relay: $0.0000050 (p99 $0.0000050, success 100.0%, sample 0)
3. LI.FI: $0.0000377 (p99 $0.0000377, success 100.0%, sample 0)
4. Near Intents: $0.00614 (p99 $0.00614, success 100.0%, sample 0)

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

**Rankings (p50, 24h):**
1. Mobula: 82 ms (p99 806 ms, success 100.0%, sample 2881)
2. deBridge: 88 ms (p99 1.56 s, success 100.0%, sample 2881)
3. Relay: 157 ms (p99 490 ms, success 97.8%, sample 2817)
4. Across: 343 ms (p99 738 ms, success 100.0%, sample 1152)
5. LI.FI: 678 ms (p99 1.83 s, success 68.8%, sample 1982)
6. Near Intents: 3.51 s (p99 4.98 s, success 99.5%, sample 1147)

**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: AVNT posts the lowest P/F ratio at 1.424x (24h) across 13 ranked protocols.

**Rankings (P/F, 24h):**
1. AVNT: P/F 1.424x (success 100.0%, sample 2880)
2. GMX: P/F 1.488x (success 100.0%, sample 2880)
3. JUP: P/F 2.71x (success 100.0%, sample 2880)
4. GNS: P/F 2.74x (success 100.0%, sample 2880)
5. EDGE: P/F 3.45x (success 100.0%, sample 2880)
6. F (SynFutures): P/F 3.52x (success 100.0%, sample 2880)
7. APEX: P/F 4.83x (success 100.0%, sample 2880)
8. ORDER: P/F 5.45x (success 100.0%, sample 2880)
9. LIT: P/F 6.44x (success 100.0%, sample 2880)
10. HYPE: P/F 11.4x (success 100.0%, sample 2880)
11. DYDX: P/F 20.0x (success 100.0%, sample 2880)
12. ASTER: P/F 21.3x (success 100.0%, sample 2880)
13. DRV: P/F 31.0x (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 $10.34B (24h) across 11 ranked venues.

**Rankings (Volume, 24h):**
1. Hyperliquid: Volume $10.34B (success 100.0%, sample 408)
2. Hyperliquid HIP-3: Volume $7.05B (success 100.0%, sample 370)
3. Lighter: Volume $3.70B (success 100.0%, sample 468)
4. Aster: Volume $2.94B (success 100.0%, sample 468)
5. Extended: Volume $191.63M (success 100.0%, sample 468)
6. GMX V2: Volume $115.35M (success 100.0%, sample 468)
7. Orderly: Volume $72.44M (success 100.0%, sample 468)
8. Gains: Volume $27.16M (success 100.0%, sample 468)
9. dYdX v4: Volume $13.98M (success 100.0%, sample 468)
10. Paradex: Volume $5.72M (success 100.0%, sample 468)
11. Aevo: Volume $3.88M (success 100.0%, sample 468)

**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: GMGN, Axiom, Fomo, Terminal, Photon, Trojan by UTC day

- 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: Axiom leads daily volume at $39.83M (24h) across 7 ranked apps.

**Rankings (Volume, 24h):**
1. Axiom: Volume $39.83M (success 100.0%, sample 1036394)
2. pump.fun: Volume $32.20M (success 100.0%, sample 1126755)
3. Fomo: Volume $30.11M (success 100.0%, sample 538918)
4. GMGN: Volume $16.29M (success 100.0%, sample 321996)
5. Terminal: Volume $7.92M (success 100.0%, sample 171873)
6. Trojan: Volume $1.14M (success 100.0%, sample 27880)
7. Photon: Volume $379.5K (success 100.0%, sample 12125)

**Methodology**:
- Source: the public API of tehcscreener (https://tehcscreener.com), served at https://tehcscreener.com/api, Allium-backed, no key, synced once a day. The single source behind every bench on the /trading-apps hub.
- Cohort change on 2026-10-07: BonkBot, Banana Gun, Bloom, Sol Trading Bot, PepeBoost and o1.exchange were removed because this source does not cover them. A row that cannot be measured is removed, not published as zero, because a zero would rank it last on a figure nobody took.
- Share: this app's volume over the cohort's total for the same window and chain. It is a share of the eight measured here, not of the whole market, and it moved when the cohort shrank.
- Chains: how many chains the app routed measurable volume on during the latest day. Reach, not quality.
- Days of history: between the app's first day in the source and its latest. A proxy for how long it has been running, bounded by when the source began tracking it.
- Single source by decision, and not cross-checked. On 2026-10-07 this source read pump.fun 2.2x above DeFiLlama on app volume while agreeing with DeFiLlama within 30% on six other platforms.
- Windows are sums over days, never averages of daily figures.

## 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
- Awaiting samples.

**Methodology**:
- Effective sample: a pooled row is judged on Kish's (sum w)^2 / sum w^2 over its priced swaps' chain weights, not on the raw count. It needs 25 effective swaps to publish and 100 to be ranked, so a product whose flow concentrates on one chain reads provisional however many swaps it holds: Binance Wallet carries 227 priced for 62 effective. The count shown in the table is the raw one.
- 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; 1,000 successful ones per Solana row per day are read and 6,000 per EVM row, 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, routed swaps included: 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), up to 2 h on BasedBot's EVM launchpad curves. 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 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.
- Settlement time: the destination block's timestamp minus the origin block's, one definition on every route and both directions. Bridged trades and wallet-funding transfers are separate columns, never pooled: the figure is a per-route mean, so a route carrying only transfers would otherwise read faster for that alone. Ten settlements minimum per column, stalls over 60 s excluded; the count is published below that floor, so a route barely seen is not read as unmeasured.
- 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 six 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 forwards a fixed 0.001 SOL on some swaps, 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.
- BasedBot takes its 1 % fee inside the swap, through Jupiter: read on 2026-10-24, 30 of 30 transactions crediting its wallet invoke a swap program in the same transaction and none is a standalone transfer. It was read the other way until then, pairing each fee to the swap before it, which left the Solana row parsed but unpriced. Its fee is now the credit inside the swap, and its failed swaps are visible like any other app's.
- One row per route, not per app: pump.fun's cross-chain trades are published twice over, as Pump Bridge (its own routers, read on chain) and as the pump.fun app (what Relay still carries). Folding them together averaged two routes into a number describing neither, and the two differ in fee, settlement time and error rate. Relay draws the same split in its own published comparison.
- Pump Bridge's rows are grossed up: its router is paid out of pump's own liquidity, already net of the 0.05 plus 40 to 45 bps it keeps, so the spend is raised back to what the user committed before the loss is taken. Both parameters come from that chain's own spends: the fixed part from pairs at different trade sizes, which solve it assuming no value, and the rate from exact read-backs. A chain with too few falls back. Residual about 2.5 bps, against 45 to 545 bps of ignoring the deduction.
- Pump Bridge's sales are priced from the delivery, not a schedule: both legs of an order carry the same sixteen-byte id, in the router event's topic1 and in the Solana payout, so what the user received is read. A sale whose id is absent or whose delivery is not held stays unpriced. The join rate is published rather than stated here, because it measures a race: a sale is usually read before its delivery exists. While the priced and drawn side mixes differ by over 20 points the row is not ranked.
- pump.fun's app charges about 45 bps to KfHbT5Jr…, counted as terminal fee. That account was filed as a Pump Bridge sell-side route until 2026-10-24, when 25 transactions crediting it were read: 23 invoke a pump swap venue and none the bridge, so it is an app fee and the row no longer reads 0. Pump Bridge differs: its deduction is grossed onto the spend and lands in Terminal as a residual. A second flagged account is pump's gas sponsor, which PAYS on every swap, so read that 0 as unmeasured.
- Pump Bridge publishes no fail rate. Failures on this route do not show up as EVM reverts (0 in about 1,050 relayer transactions read on Robinhood Chain on 2026-10-22), and most of its swaps are sent to the user's own proxy rather than to the router, so a block sample of router transactions sees about 3 % of them (tfq_router_direct_total). Its error rate is not measurable from the chain here.
- MegaETH and X Layer are read but not shown: Pump Bridge's router is deployed on both and no bridge aggregator covers either, so this is the only measurement of them, but MegaETH has never executed a trade (relayer nonce 0) and X Layer had one priced swap on 2026-10-22. They get a chain tab when they carry enough trades to publish one; until then a tab would answer nothing.
- 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.

## 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, 42 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. dRPC: p50 42 ms, p90 135 ms, p99 183 ms (success 99.9%, sample 4319.75)
2. Arc: p50 45 ms, p90 56 ms, p99 116 ms (success 100.0%, sample 4319.75)
3. Quicknode (Arc endpoint): p50 45 ms, p90 84 ms, p99 201 ms (success 100.0%, sample 4317.75)
4. PublicNode: p50 78 ms, p90 91 ms, p99 228 ms (success 100.0%, sample 4319.75)
5. Tenderly Gateway: p50 106 ms, p90 113 ms, p99 134 ms (success 100.0%, sample 4317.75)
6. Blockdaemon: p50 111 ms, p90 116 ms, p99 356 ms (success 100.0%, sample 4320.75)

**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: Quicknode has the lowest median latency of the 6 private (API-key) Arc RPC endpoints measured, 4 ms (p50, 24h, 3 regions).
1. Quicknode: 4 ms (p99 33 ms, success 100.0%, sample 720.125)
2. Chainstack: 6 ms (p99 8 ms, success 100.0%, sample 720.125)
3. GetBlock: 13 ms (p99 44 ms, success 100.0%, sample 720.125)
4. Alchemy: 14 ms (p99 84 ms, success 100.0%, sample 720.125)
5. Dwellir: 35 ms (p99 153 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 106 ms (p99 154 ms, success 100.0%, sample 1078.19)

**Private, cold start cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/arc-rpc#tier=keyed-cold
- JSON: https://openchainbench.com/api/stat/arc-rpc?tier=keyed-cold
- Headline: GetBlock has the lowest median latency of the 6 free public Arc RPC endpoints measured, 36 ms (p50, 24h, 3 regions).
1. GetBlock: 36 ms (p99 72 ms, success 100.0%, sample 720.125)
2. Alchemy: 39 ms (p99 219 ms, success 100.0%, sample 720.125)
3. Chainstack: 43 ms (p99 271 ms, success 100.0%, sample 720.125)
4. Quicknode: 51 ms (p99 585 ms, success 100.0%, sample 720.125)
5. Dwellir: 183 ms (p99 404 ms, success 100.0%, sample 1080.19)
6. BlockMachine: 292 ms (p99 470 ms, success 100.0%, sample 1080.19)

**Private, heavy call cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/arc-rpc#tier=keyed-heavy
- JSON: https://openchainbench.com/api/stat/arc-rpc?tier=keyed-heavy
- Headline: Alchemy has the lowest median latency of the 6 free public Arc RPC endpoints measured, 13 ms (p50, 24h, 3 regions).
1. Alchemy: 13 ms (p99 89 ms, success 100.0%, sample 42)
2. GetBlock: 17 ms (p99 21 ms, success 100.0%, sample 28)
3. Chainstack: 31 ms (p99 78 ms, success 100.0%, sample 42)
4. Dwellir: 37 ms (p99 50 ms, success 100.0%, sample 42)
5. Quicknode: 126 ms (p99 304 ms, success 100.0%, sample 42)
6. BlockMachine: 126 ms (p99 173 ms, success 100.0%, sample 42)

**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 the same 3 regions; its headline averages us-east and eu-west only, for the GetBlock coverage reason below. 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- 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, Quicknode, Dwellir and BlockMachine probed on their keyed Arc endpoints every 120 seconds from all 3 probe 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: Chainstack: a Global Node on the Growth plan; Quicknode: an endpoint on a Build plan ($49 per month), shared fleet; Alchemy: an Enterprise trial key, measured on that tier since 10 November 2026, not a reader's tier; Alchemy states free and paid keys share one routing; GetBlock: an endpoint on the Enterprise plan, shared by the two probe regions. Chainstack, GetBlock and Quicknode provided their endpoints.
- Dwellir plan tier, disclosed: a Developer plan key ($49 per month, 25 million API responses, 100 responses per second; 1 RPC response = 1 API credit, no compute units). Shared nodes, the same product a reader buys. Dwellir publishes no Solana endpoint, so it is absent from that page rather than shown as unavailable.
- 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 figure exists for that region: the endpoint is not offered there, which is not a failed or pending measurement. The keyed headline therefore averages us-east and eu-west for every vendor, because averaging a two-region row against three-region rows would compare different populations. Singapore is published per region for the five vendors that answer the Singapore 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.
- 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: StandX posts the lowest volume / OI (24h) at 0.028x (p50, 24h) across 22 ranked venues.

**Rankings (p50, 24h):**
1. StandX: 0.028x (p99 0.050x, success 80.0%, sample 2880)
2. Paradex: 0.251x (p99 0.489x, success 100.0%, sample 2880)
3. Aevo: 0.263x (p99 0.386x, success 81.0%, sample 2880)
4. dYdX v4: 0.345x (p99 0.601x, success 100.0%, sample 2880)
5. Ostium: 0.357x (p99 0.357x, success 60.0%, sample 2880)
6. Hyperliquid: 1.562x (p99 2.02x, success 100.0%, sample 2880)
7. trade.xyz: 1.624x (p99 1.812x, success 80.0%, sample 2880)
8. GRVT: 1.857x (p99 2.07x, success 83.3%, sample 2880)
9. Polymarket: 2.33x (p99 2.81x, success 80.0%, sample 2880)
10. Aster: 2.39x (p99 2.95x, success 100.0%, sample 2880)
11. edgeX: 3.07x (p99 4.07x, success 83.2%, sample 2880)
12. Extended: 3.61x (p99 4.27x, success 99.8%, sample 2880)
13. Nado: 3.96x (p99 8.62x, success 82.9%, sample 2880)
14. Lighter RH: 4.84x (p99 5.17x, success 80.0%, sample 2880)
15. ApeX Omni: 6.28x (p99 6.91x, success 80.0%, sample 2880)
16. Lighter: 7.59x (p99 8.92x, success 100.0%, sample 2880)
17. Gains: 8.28x (p99 9.46x, success 100.0%, sample 2880)
18. Pacifica: 9.11x (p99 10.2x, success 83.3%, sample 2880)
19. Ondo Perps: 10.1x (p99 11.5x, success 79.8%, sample 2880)
20. Jupiter Perps: 11.7x (p99 24.9x, success 80.0%, sample 2880)
21. Kalshi: 45.1x (p99 47.7x, success 79.9%, sample 2880)
22. Papertrade: 105.6x (p99 112.6x, 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.
- Nova is excluded for the opposite reason: both series exist and the open interest is too small to divide by. On 2026-10-22 it held 11269 USD across a single pair against 1.38M USD of 24h volume, a ratio of 123x that would top this board. That describes a venue with almost no open positions rather than one turning its book over 123 times a day, and one position opening would halve it. It joins when the denominator is large enough for the quotient to mean what the other rows mean.
- 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: Vest posts the lowest funding paid, 30d ETH long at 8.76 bps (30 days at the average daily rate) across 22 ranked venues.

**Rankings (p50, 30d):**
1. Vest: 8.76 bps (p99 -83.5 bps, success 100.0%, sample 720)
2. Deribit: 11.6 bps (p99 46.1 bps, success 100.0%, sample 720)
3. OKX: 17.4 bps (p99 22.3 bps, success 100.0%, sample 720)
4. KuCoin: 19.1 bps (p99 9.84 bps, success 100.0%, sample 720)
5. Bybit: 22.7 bps (p99 18.1 bps, success 100.0%, sample 720)
6. Binance: 23.2 bps (p99 9.06 bps, success 100.0%, sample 720)
7. Gate: 25.2 bps (p99 25.1 bps, success 100.0%, sample 720)
8. Bitget: 26.9 bps (p99 10.1 bps, success 100.0%, sample 720)
9. MEXC: 28.4 bps (p99 32.8 bps, success 100.0%, sample 720)
10. Kalshi: 28.9 bps (p99 -56.6 bps, success 100.0%, sample 720)
11. Kraken: 30.1 bps (p99 5.74 bps, success 100.0%, sample 720)
12. Hyperliquid: 42.5 bps (p99 36.5 bps, success 100.0%, sample 720)
13. Aster: 42.7 bps (p99 38.4 bps, success 100.0%, sample 720)
14. StandX: 52.5 bps (p99 89.6 bps, success 100.0%, sample 720)
15. Lighter: 54.1 bps (p99 46.4 bps, success 100.0%, sample 720)
16. Lighter RH: 54.5 bps (p99 48.8 bps, success 100.0%, sample 720)
17. edgeX: 63.4 bps (p99 72.2 bps, success 100.0%, sample 720)
18. Pacifica: 72.2 bps (p99 68.7 bps, success 100.0%, sample 720)
19. Ondo Perps: 72.7 bps (p99 89.3 bps, success 100.0%, sample 720)
20. Extended: 75.0 bps (p99 73.4 bps, success 100.0%, sample 718)
21. ApeX Omni: 84.7 bps (p99 52.9 bps, success 100.0%, sample 720)
22. Polymarket: 88.2 bps (p99 34.0 bps, success 100.0%, sample 720)

**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.
- A dormant market reads as an expensive one over thirty days. Coinbase International settled its last funding on 1 October 2026 and reports zero notional on 24h, daily and 30 day volume, so the feed kept relaying that final rate: 9.36 bps a day on ETH for twenty of these thirty days, ranking it last at 227 bps against 91 for the next worst. It left the cohort on 21 October. Freshness checks stayed green, because they read a refresh timestamp and a repeated value advances one.

## 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: Arbitrum One leads bridged TVL at $7.14B (latest value) across 39 ranked chains.

**Rankings (p50, 24h):**
1. Arbitrum One: $7.14B (p99 $7.14B, success 100.0%, sample 2880)
2. Base: $7.09B (p99 $7.09B, success 100.0%, sample 2880)
3. Hyperliquid: $5.63B (p99 $5.63B, success 100.0%, sample 2880)
4. Polygon PoS: $3.43B (p99 $3.43B, success 100.0%, sample 2880)
5. Robinhood Chain: $1.46B (p99 $1.46B, success 100.0%, sample 2880)
6. Optimism: $1.04B (p99 $1.04B, success 100.0%, sample 2880)
7. Mantle: $914.09M (p99 $914.09M, success 100.0%, sample 2880)
8. Ink: $791.80M (p99 $791.80M, success 100.0%, sample 2880)
9. X Layer: $270.63M (p99 $270.63M, success 100.0%, sample 2880)
10. Linea: $232.84M (p99 $232.84M, success 100.0%, sample 2880)
11. Starknet: $223.38M (p99 $223.38M, success 100.0%, sample 2880)
12. World Chain: $210.34M (p99 $210.34M, success 100.0%, sample 2880)
13. Gnosis: $190.55M (p99 $190.55M, success 100.0%, sample 2880)
14. Fraxtal: $148.15M (p99 $148.15M, success 100.0%, sample 2880)
15. Morph: $125.33M (p99 $125.33M, success 100.0%, sample 2880)
16. Ronin: $96.06M (p99 $96.06M, success 100.0%, sample 2880)
17. zkSync Era: $90.73M (p99 $90.73M, success 100.0%, sample 2880)
18. Unichain: $88.53M (p99 $88.53M, success 100.0%, sample 2880)
19. Manta Pacific: $51.61M (p99 $51.61M, success 100.0%, sample 2880)
20. Plume: $48.51M (p99 $48.51M, success 100.0%, sample 2880)
21. BOB: $42.29M (p99 $42.29M, success 100.0%, sample 2880)
22. MegaETH: $28.60M (p99 $28.60M, success 100.0%, sample 2880)
23. Scroll: $24.61M (p99 $24.61M, success 100.0%, sample 2880)
24. Metis: $19.40M (p99 $19.40M, success 100.0%, sample 2880)
25. Celo: $17.48M (p99 $17.48M, success 100.0%, sample 2880)
26. Immutable zkEVM: $16.42M (p99 $16.42M, success 100.0%, sample 2880)
27. Soneium: $14.40M (p99 $14.40M, success 100.0%, sample 2880)
28. Abstract: $11.51M (p99 $11.51M, success 100.0%, sample 2880)
29. Taiko: $9.62M (p99 $9.62M, success 100.0%, sample 2880)
30. ApeChain: $8.49M (p99 $8.49M, success 100.0%, sample 2880)
31. Zircuit: $7.63M (p99 $7.63M, success 100.0%, sample 2880)
32. Polygon zkEVM: $7.21M (p99 $7.21M, success 100.0%, sample 2880)
33. Arbitrum Nova: $6.72M (p99 $6.72M, success 100.0%, sample 2880)
34. Boba Network: $4.43M (p99 $4.43M, success 100.0%, sample 2880)
35. Mode: $4.36M (p99 $4.36M, success 100.0%, sample 2880)
36. Reya Network: $3.22M (p99 $3.22M, success 100.0%, sample 2880)
37. Zora: $3.10M (p99 $3.10M, success 100.0%, sample 2880)
38. Cyber: $1.97M (p99 $1.97M, success 100.0%, sample 2880)
39. Hemi: $440.9K (p99 $440.9K, 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: Securitize posts the lowest P/F ratio at 0.230x (latest value) across 61 ranked protocols.

**Rankings (P/F, 24h):**
1. Securitize: P/F 0.230x (success 100.0%, sample 1440)
2. Sanctum: P/F 0.265x (success 100.0%, sample 1440)
3. Lido: P/F 0.288x (success 100.0%, sample 1440)
4. Dolomite: P/F 0.435x (success 100.0%, sample 1440)
5. Meteora: P/F 0.503x (success 100.0%, sample 1440)
6. Centrifuge: P/F 0.526x (success 100.0%, sample 1440)
7. Pump: P/F 0.549x (success 100.0%, sample 1440)
8. Graphite Protocol: P/F 0.588x (success 100.0%, sample 1440)
9. StonkFun: P/F 0.703x (success 100.0%, sample 1440)
10. Pons: P/F 0.768x (success 100.0%, sample 1440)
11. Benqi: P/F 0.817x (success 100.0%, sample 1440)
12. Maple Finance: P/F 0.851x (success 100.0%, sample 1440)
13. Orca: P/F 0.956x (success 100.0%, sample 1440)
14. Chainflip: P/F 1.005x (success 100.0%, sample 1440)
15. Rocket Pool: P/F 1.078x (success 100.0%, sample 1440)
16. NAVI Protocol: P/F 1.093x (success 100.0%, sample 1440)
17. Re: P/F 1.129x (success 100.0%, sample 1440)
18. Rhea Finance: P/F 1.348x (success 100.0%, sample 1440)
19. stake.link: P/F 1.356x (success 100.0%, sample 1440)
20. CoWSwap: P/F 1.370x (success 100.0%, sample 1440)
21. USD AI: P/F 1.380x (success 100.0%, sample 1440)
22. GMX: P/F 1.435x (success 100.0%, sample 1440)
23. Stader: P/F 1.480x (success 100.0%, sample 1440)
24. Ekubo Protocol: P/F 1.733x (success 100.0%, sample 1440)
25. Lista DAO: P/F 2.09x (success 100.0%, sample 1440)
26. Raydium: P/F 2.25x (success 100.0%, sample 1440)
27. Venus: P/F 2.28x (success 100.0%, sample 1440)
28. Morpho: P/F 2.36x (success 100.0%, sample 1440)
29. Frax Finance: P/F 2.42x (success 100.0%, sample 1440)
30. ether.fi: P/F 2.53x (success 100.0%, sample 1440)
31. Kamino: P/F 2.65x (success 100.0%, sample 1440)
32. Jupiter: P/F 2.67x (success 100.0%, sample 1440)
33. Aave: P/F 2.71x (success 100.0%, sample 1440)
34. Moonwell: P/F 2.78x (success 100.0%, sample 1440)
35. KyberSwap: P/F 2.81x (success 100.0%, sample 1440)
36. THORChain DEX: P/F 2.83x (success 100.0%, sample 1440)
37. Kinetiq: P/F 2.84x (success 100.0%, sample 1440)
38. Euler: P/F 2.91x (success 100.0%, sample 1440)
39. Uniswap: P/F 3.08x (success 100.0%, sample 1440)
40. Fluid: P/F 3.11x (success 100.0%, sample 1440)
41. Cetus: P/F 3.36x (success 100.0%, sample 1440)
42. Gains Network: P/F 3.36x (success 100.0%, sample 1440)
43. edgeX: P/F 3.43x (success 100.0%, sample 1440)
44. PancakeSwap: P/F 3.74x (success 100.0%, sample 1440)
45. Curve Finance: P/F 4.38x (success 100.0%, sample 1440)
46. BONK.fun: P/F 4.74x (success 100.0%, sample 1440)
47. ApeX Protocol: P/F 4.80x (success 100.0%, sample 1440)
48. Sushi: P/F 4.94x (success 100.0%, sample 1440)
49. Convex Finance: P/F 5.29x (success 100.0%, sample 1440)
50. Compound Finance: P/F 5.43x (success 100.0%, sample 1440)
51. Lighter: P/F 6.37x (success 100.0%, sample 1440)
52. Hyperliquid: P/F 11.3x (success 100.0%, sample 1440)
53. World Liberty Financial: P/F 11.3x (success 100.0%, sample 1440)
54. Definitive: P/F 11.4x (success 100.0%, sample 1440)
55. Ondo Finance: P/F 13.6x (success 100.0%, sample 1440)
56. SUN: P/F 14.6x (success 100.0%, sample 1440)
57. Aster: P/F 21.6x (success 100.0%, sample 1440)
58. cap: P/F 26.4x (success 100.0%, sample 1440)
59. o1.exchange: P/F 27.0x (success 100.0%, sample 1440)
60. JustLend: P/F 29.2x (success 100.0%, sample 1440)
61. Pendle: P/F 30.6x (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: Ink leads net stablecoin flow (30d) at $305.18M (latest value) across 26 ranked chains.

**Rankings (p50, 24h):**
1. Ink: $305.18M (p99 $305.18M, success 100.0%, sample 2880)
2. Aptos: $235.30M (p99 $235.30M, success 100.0%, sample 2880)
3. Sui: $121.83M (p99 $121.83M, success 100.0%, sample 2880)
4. Plasma: $112.27M (p99 $112.27M, success 100.0%, sample 2880)
5. Celo: $768.4K (p99 $768.4K, success 100.0%, sample 2880)
6. Cronos: -$3.27M (p99 -$3.27M, success 100.0%, sample 2880)
7. Stellar: -$3.94M (p99 -$3.94M, success 100.0%, sample 2880)
8. Polygon PoS: -$6.81M (p99 -$6.81M, success 100.0%, sample 2880)
9. Arbitrum One: -$7.69M (p99 -$7.69M, success 100.0%, sample 2880)
10. Sei: -$10.87M (p99 -$10.87M, success 100.0%, sample 2880)
11. Sonic: -$17.91M (p99 -$17.91M, success 100.0%, sample 2880)
12. X Layer: -$35.44M (p99 -$35.44M, success 100.0%, sample 2880)
13. Mantle: -$50.03M (p99 -$50.03M, success 100.0%, sample 2880)
14. Optimism: -$61.68M (p99 -$61.68M, success 100.0%, sample 2880)
15. Gram: -$80.49M (p99 -$80.49M, success 100.0%, sample 2880)
16. Monad: -$90.75M (p99 -$90.75M, success 100.0%, sample 2880)
17. Avalanche: -$98.76M (p99 -$98.76M, success 100.0%, sample 2880)
18. Robinhood Chain: -$109.87M (p99 -$109.87M, success 100.0%, sample 2880)
19. Starknet: -$111.74M (p99 -$111.74M, success 100.0%, sample 2880)
20. XRP Ledger: -$142.41M (p99 -$142.41M, success 100.0%, sample 2880)
21. Base: -$278.12M (p99 -$278.12M, success 100.0%, sample 2880)
22. BNB Chain: -$315.31M (p99 -$315.31M, success 100.0%, sample 2880)
23. Hyperliquid: -$1.21B (p99 -$1.21B, success 100.0%, sample 2880)
24. TRON: -$1.65B (p99 -$1.65B, success 100.0%, sample 2880)
25. Solana: -$2.02B (p99 -$2.02B, success 100.0%, sample 2880)
26. Ethereum: -$14.22B (p99 -$14.22B, 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.29B (24h) across 11 ranked venues.

**Rankings (p50, 24h):**
1. Kalshi: $1.29B (p99 $1.41B, success 100.0%, sample 2880)
2. Polymarket: $314.98M (p99 $323.41M, success 100.0%, sample 2880)
3. Predict Fun: $9.90M (p99 $11.02M, success 100.0%, sample 2880)
4. OPINION: $2.71M (p99 $2.73M, success 100.0%, sample 2880)
5. Trueo: $1.87M (p99 $1.88M, success 100.0%, sample 2880)
6. PredictStreet: $1.78M (p99 $1.78M, success 100.0%, sample 2880)
7. Sport.fun: $1.75M (p99 $1.76M, success 100.0%, sample 2880)
8. Pascal: $1.73M (p99 $1.73M, success 100.0%, sample 2880)
9. Augur: $1.01M (p99 $1.07M, success 100.0%, sample 2880)
10. Overtime: $983.6K (p99 $1.01M, success 100.0%, sample 2880)
11. Levr Bet: $547.8K (p99 $547.9K, 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.63 bps (p50, 24h) across 13 ranked tokenized assets.

**Rankings (Cost $100k, 24h):**
1. USDY: Cost $100k 3.63 bps, p99 $100k 3.63 bps (success 100.0%, sample 2880)
2. NVDAx: Cost $100k 36.2 bps, p99 $100k 191 bps (success 100.0%, sample 2880)
3. SPYx: Cost $100k 75.2 bps, p99 $100k 103 bps (success 100.0%, sample 2880)
4. TSLAx: Cost $100k 108 bps, p99 $100k 137 bps (success 100.0%, sample 2880)
5. QQQx: Cost $100k 157 bps, p99 $100k 172 bps (success 100.0%, sample 2880)
6. AAPLx: Cost $100k 178 bps, p99 $100k 262 bps (success 100.0%, sample 2880)
7. MSFTx: Cost $100k 239 bps, p99 $100k 299 bps (success 100.0%, sample 2880)
8. AMZNx: Cost $100k 360 bps, p99 $100k 413 bps (success 100.0%, sample 2880)
9. GOOGLx: Cost $100k 363 bps, p99 $100k 869 bps (success 100.0%, sample 2880)
10. METAx: Cost $100k 466 bps, p99 $100k 626 bps (success 100.0%, sample 2880)
11. PAXG: Cost $100k 3608 bps, p99 $100k 8658 bps (success 100.0%, sample 2880)
12. COINx: Cost $100k 4106 bps, p99 $100k 8781 bps (success 100.0%, sample 2880)
13. PLTRx: Cost $100k 5581 bps, p99 $100k 5829 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
- Awaiting samples.

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

## Cheapest RPC provider, priced per workload across 19 providers

- Category: RPCs
- Metric: Monthly cost, dapp mix at 10M requests (usd)
- Page: https://openchainbench.com/benchmarks/rpc-cost
- JSON: https://openchainbench.com/api/stat/rpc-cost
- Status: live
- Headline: Blockmachine posts the lowest monthly cost, dapp mix at 10M requests at $25 (latest value) across 16 ranked providers, measured on Dapp frontend, 10M requests/mo, Cheapest paid plan.

**Rankings (Monthly bill, 24h):**
1. Blockmachine: Monthly bill $25 (success 100.0%, sample 4)
2. BlockPI: Monthly bill $29.50 (success 100.0%, sample 4)
3. Chainstack: Monthly bill $49 (success 100.0%, sample 4)
4. dRPC: Monthly bill $49 (success 100.0%, sample 4)
5. Dwellir: Monthly bill $49 (success 100.0%, sample 4)
6. OnFinality: Monthly bill $49 (success 100.0%, sample 4)
7. NOWNodes: Monthly bill $102.20 (success 100.0%, sample 4)
8. Alchemy: Monthly bill $125.48 (success 100.0%, sample 4)
9. Quicknode: Monthly bill $129.60 (success 100.0%, sample 4)
10. Validation Cloud: Monthly bill $167 (success 100.0%, sample 4)
11. thirdweb: Monthly bill $171 (success 100.0%, sample 4)
12. GetBlock: Monthly bill $199 (success 100.0%, sample 4)
13. Ankr: Monthly bill $200 (success 100.0%, sample 4)
14. Infura (MetaMask Developer): Monthly bill $225 (success 100.0%, sample 4)
15. Moralis: Monthly bill $249 (success 100.0%, sample 4)
16. Tatum: Monthly bill $287 (success 100.0%, sample 4)

**Dedicated capacity cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/rpc-cost#tier=dedicated
- JSON: https://openchainbench.com/api/stat/rpc-cost?tier=dedicated
- Headline: Cheapest RPC provider, priced per workload across 19 providers. 6 providers measured; none is ranked on this benchmark.

**Free public, not ranked cohort** (ranked separately, never against the rows above):
- Page: https://openchainbench.com/benchmarks/rpc-cost#tier=reference
- JSON: https://openchainbench.com/api/stat/rpc-cost?tier=reference
- Headline: Cheapest RPC provider, priced per workload across 19 providers. 1 provider measured; none is ranked on this benchmark.

**Methodology**:
- Cohort. 19 providers billed per request, ranked per workload. Blockdaemon (every paid plan behind a sales call) and Coinbase CDP (Base only) cannot fill a cell. Flat-rate nodes are priced in the calculator, not the per-workload grid. PublicNode and the Solana Foundation endpoints are published but never ranked: free and usable, and PublicNode publishes no rate limit at all, so calling it cheapest would be true and useless.
- Chains. Ethereum and Solana only: the two chains most of the cohort prices, and pricing a third would mostly price which providers serve it. Ethereum carries four workload profiles and Solana one, a trading-bot mix; Blockmachine, Dwellir and several others price no Solana at all. Several providers weight other chains differently, so a Base or Polygon bill is not this page's Ethereum bill.
- Normalisation. Every provider's published method table is applied to the profile's method mix to get weighted units per request, and that figure is published as rpc_cost_units_per_request so the arithmetic is checkable.
- Most large providers do not price per method at all. Chainstack charges 1 Request Unit for a read and 2 at archive depth, decided by block age (127+ blocks behind tip), while debug and trace are 2 at any depth. Quicknode weights per chain, Ethereum 20 credits and Solana 30, with x2 for advanced calls and x4 for large ones. GetBlock multiplies a chain factor spanning 10 to 300.
- Archive. Handled per provider rather than as a uniform surcharge, because it is not one. Chainstack doubles on block age. BlockPI adds 30% to the whole endpoint. Alchemy, dRPC, Quicknode and Blockmachine charge no archive premium at all, and neither does Dwellir, which bills 1 credit per response on every method, archive, debug and trace included; that archive is served on its shared plans is stated in Dwellir's own Ethereum comparison post rather than its price table.
- GetBlock publishes an independent archive column, 2x on plain reads and 3x on debug and trace, so no single multiplier is correct and its own published formula is arithmetically impossible against its own API. Tatum serves archive but has never published what it charges for it in the credit model, so it is reported unpriceable on archive workloads rather than assigned a guess.
- Eligibility before price. A plan is ranked only if it can serve the workload. Daily caps are compared against the daily share, not the monthly total, because Infura's credits do not roll over. Hard stops (Infura, NOWNodes Start and Pro, Quicknode's trial) make a plan unavailable above its cap rather than merely expensive. Published throughput is checked against the sustained rate the volume requires. Missing trace or archive access is unavailability, not cost.
- Plan tiers. Provider plan names do not line up, Chainstack calls $49 Growth and Helius calls $499 Business, so plans are banded by monthly price into free, entry (to $50), growth (to $300), business (to $1,000) and enterprise. The default view is the cheapest paid plan. Free plans are not banded here at all: every one ties at $0, so this page would order them by their overage bill, and it is bench 283 that ranks them on what their allowance buys.
- One-off offers are not monthly prices. Quicknode's one-month trial, NOWNodes' one-month Start and Tatum's lifetime 100,000 credits each cost $0 and never renew, so they are excluded rather than quoted. All three are banded as paid plans by what they become: $49 Build, EUR 20 Pro, $49 Starter. A plan that recurs at $0 is kept, because that is a price. Validation Cloud's Scale carries no subscription and its first 50M compute units are free.
- Any volume, not only three. The per-workload grid prices 10M, 100M and 1B requests a month because a metric needs a fixed label. The calculator prices anything from 100,000 to 5B, reading a curve the same harness emits through the same model, with a point at every plan boundary and a straight line between them, which is the real shape of a metered bill. The three grid volumes are marked on its track so the two can be checked against each other.
- Free tiers moved to bench 283 (rpc-free-tier), ranked by what the allowance buys rather than by price. GetBlock advertises 20 requests per second and 50,000 compute units per day: at its own advertised rate the daily allowance is gone in 125 seconds. Infura's lasts 1.7 hours a day, OnFinality's 2.8 hours, Alchemy's 1.2 days a month. Bench 283 publishes the allowance converted into requests of each profile, alongside the throughput cap that is often the real ceiling.
- Add-ons are priced with their prerequisites. Infura's $200 extra-credits pack cannot be bought on the free tier, so its real entry cost is Developer at $50 plus $200, which loses to Team at $225. Helius advertises dedicated nodes from $2,900 and states that mainnet requires a Business or Professional plan, so the floor priced here is $2,900 plus the $499 Business plan, $3,399 a month.
- Packages are pro-rated, not treated as subscriptions. BlockPI sells 500M Request Units for $49 over 60 days and 4,000M for $299 over 90 days, and its own page says 'without monthly subscription'. Both price and allowance are scaled to 30 days ($24.50 and $99.67), and unused units are forfeited at expiry.
- Currency and period. A 30-day month throughout. NOWNodes prices in EUR and stays in EUR in the catalogue; the ECB reference rate sits in the catalogue header so the conversion is visible at the point of use rather than baked into a number.
- Verification. Every figure was collected and then independently re-verified against the primary source by a second pass, which corrected about thirty values, including two that had been computed and then presented as published. A later adversarial audit corrected a dozen more, most of them in this prose rather than in the data.
- Conflicts between a provider's own pages are reported rather than silently resolved. Alchemy's free-tier throughput was settled by a dated docs commit, Helius's archival credit cost by dating the documentation table, and Ankr's live model by reading its production application bundle, because its most machine-readable pricing page describes a model that is not the one being sold.
- Freshness. The catalogue is committed and human-verified, not scraped, because most of this cohort publishes price as prose. 20 pages carry a baseline hash recorded when a human last read the numbers under them; the harness re-hashes each once a cycle and alerts the maintainers on a change, and the page shows the catalogue date.
- The rest are marked for manual re-reading and deliberately not polled: a page that churns for reasons unrelated to price would alarm every cycle and teach everyone to ignore the alarm. Every figure keeps the date a human last read it in the catalogue, so a figure nobody has re-read is visible as such.
- Sixteen of the ranked providers expose a machine-readable pricing artifact, whether JSON or raw markdown, and four of them, GetBlock, NOWNodes, Quicknode and Tatum, expose unauthenticated pricing APIs a harness can poll directly. 20 pages across the cohort are re-hashed on a loop.
- Measured, not just read. Chainstack's rules were tested against its billing API with 291 counted calls: 1 Request Unit for a full request, archive above 2x full, debug and trace at 2 RU even ten blocks behind tip (so the surcharge is method-driven, not recency-driven), and an HTTP batch of 30 billed as 30 rather than 1. The 127-block archive boundary the indexer and trace profiles rest on is confirmed to within five blocks: it is not 64, not 256 and not absent.
- Two measurement traps worth publishing. Chainstack's per-node Request Unit column does not reconcile: two nodes came in at minus 66 and plus 59 against prediction, cancelling on the total, so it cannot be used for spend attribution.
- And that counter is not live. It stayed flat for twelve minutes while 57 calls were served, because each hourly row covers the hour ending at its label and appears about fifty minutes later. A naive read, burst, re-read measurement concludes Chainstack bills nothing at all.
- Two limits come from what providers do not publish, and no amount of access would close them. Quicknode publishes its rate limits in requests per second while its own support states they are enforced in credits per second, and declines to give those numbers, so the throughput check here compares requests against a ceiling that really applies to weighted units: on a heavy method mix Quicknode reaches its real limit earlier than this page predicts.
- And Alchemy publishes no fallback cost for methods absent from its table, so a workload using an unlisted method cannot be priced at all. The five profiles here use only listed methods, but a reader with an unusual mix cannot extend the table without asking Alchemy.
- dRPC's Pro ($49) and Scale ($199), launched 2026-10-20, spend fewer Compute Units per request from one pool shared across chains: 16 or 14 on Multi-Chain, 13 on Solana, against 20 on Pay as You Go. Each is priced here once per chain with its pool converted into requests, which is exact for a workload on one chain. Pay as You Go is now capped at 100 requests a second for new accounts, so it cannot serve a billion requests a month.
- Blockmachine bills only successful responses: its pricing page states that failed requests cost nothing. A per-request model cannot see that, so on a workload with failures its real bill is at or below the figure here. Its rate limit is metered in Request Units per minute rather than requests, so a 25-unit trace call spends 25 of it, and the throughput check uses billing units for that reason.
- Method costs are modelled once per provider, varied by chain and by archive depth but not by plan. Where a provider negotiates or varies weights per account, the figures here are its published list prices.
- What is still not measured. These are published prices, not invoices. Alchemy and Quicknode carry no credit, compute-unit or quota header on any response, so their billed units cannot be confirmed without dashboard credentials we do not hold. Where a provider's real charge is non-deterministic by design, dRPC routes to third-party operators that can rewrite the price downward and exposes no per-response cost header, the published rate is reported as an upper bound and labelled as one.

## Most requests a free RPC plan buys, across 13 providers

- Category: RPCs
- Metric: Free allowance (count)
- Page: https://openchainbench.com/benchmarks/rpc-free-tier
- JSON: https://openchainbench.com/api/stat/rpc-free-tier
- Status: live
- Headline: dRPC leads free allowance at 10.50M (p50, 24h) across 11 ranked plans, measured on Dapp frontend, Ethereum.

**Rankings (Free allowance, 24h):**
1. dRPC: Free allowance 10.50M, Least generous workload 10.50M, Most generous workload 10.50M (success 100.0%, sample n/a)
2. OnFinality: Free allowance 6.86M, Least generous workload 2.40M, Most generous workload 12.00M (success 100.0%, sample n/a)
3. Chainstack: Free allowance 3.00M, Least generous workload 1.50M, Most generous workload 3.00M (success 100.0%, sample n/a)
4. BlockPI: Free allowance 1.82M, Least generous workload 392.5K, Most generous workload 3.33M (success 100.0%, sample n/a)
5. Alchemy: Free allowance 1.26M, Least generous workload 750.0K, Most generous workload 1.50M (success 100.0%, sample n/a)
6. Validation Cloud: Free allowance 1.22M, Least generous workload 1.22M, Most generous workload 1.25M (success 100.0%, sample n/a)
7. Ankr: Free allowance 1.00M, Least generous workload 1.00M, Most generous workload 1.00M (success 100.0%, sample n/a)
8. Infura: Free allowance 902.3K, Least generous workload 226.4K, Most generous workload 1.13M (success 100.0%, sample n/a)
9. Blockdaemon: Free allowance 191.7K, Least generous workload 109.1K, Most generous workload 600.0K (success 100.0%, sample n/a)
10. GetBlock: Free allowance 75.0K, Least generous workload 14.4K, Most generous workload 75.0K (success 100.0%, sample n/a)
11. Blockmachine: Free allowance 10.0K, Least generous workload 397, Most generous workload 10.0K (success 100.0%, sample n/a)

**Methodology**:
- Allowance source: each provider's published free plan, read from its own pricing page or API, with the date of reading and a confidence flag recorded in the catalogue. The same catalogue prices the paid plans on bench 282; this page reads only the rows whose monthly price is zero and whose allowance renews.
- Confidence, stated rather than implied. Eight of the eleven ranked allowances are verified against the provider's own published figure. Three are not, and all three are named here. dRPC publishes its 210M CU allowance but nothing about what happens on exhausting it. Blockdaemon's documentation disagrees with itself: an October plan table says 1M CU a month where an April page and an archived pricing card say 3M, and 3M is what two sources carry.
- The third is Blockmachine. Its own pages agree on 10,000 Request Units a month and disagree on the rest: the pricing card gives the Free plan 300 requests a minute and archive access, the plan table in its llms.txt 100 Request Units a minute and archive from the paid Standard plan up.
- Unit conversion: allowance divided by the weighted cost of one request of the selected workload, in the provider's own unit. A workload is a fixed method mix with shares that sum to 1, so the weighted cost is the sum of each method's unit weight times its share. A provider that meters flat requests has a weight of 1 on every method.
- Periods that are not a month: Infura, GetBlock and OnFinality publish a daily allowance, multiplied by 30, the most generous reading, and OnFinality at 40 response units a second cannot reach its monthly figure in a burst. BlockPI's 50M RU package arrives on the 1st of every month and stays valid 32 days without accumulating, so a month delivers 50M and the overlap is forfeited. Every plan stays subject to its throughput ceiling, which this page does not score.
- What counts as free: a plan that costs nothing and renews. Quicknode's Free trial is excluded because it runs for one month and does not renew; it is priced on bench 282 as an entry plan instead. Public endpoints with no key and no published allowance are also excluded: there is no allowance to rank. Blockmachine's keyless endpoint is one, 60 Request Units a minute per IP with no monthly cap and no archive; its keyed Free plan, 10,000 Request Units a month, is the row ranked here.
- Headline slice: the unfiltered view is the dapp mix on Ethereum, published under the `all` label as the headline slice and not as a pooled average, because an allowance averaged across workloads describes none of them. Switching a tab reads a different slice, never a blend. The chain is a property of the workload rather than a second axis: the Ethereum mixes cover 11 of the 13 plans and the Solana bot mix covers 11, so a provider absent from one tab serves a chain that tab does not ask about.
- Floor and ceiling: the two columns beside the headline are the least and the most generous of the workloads that plan serves on the selected chain, over all five priced mixes including the simple-read mix, which has no tab. They describe the plan rather than the open tab, so they read the same on every tab. A workload the plan refuses is excluded, not counted as zero: Alchemy's free tier does no trace, so its floor is its indexer mix and the refusal shows as its absence from the trace tab.
- Why the span is reported and not collapsed: the two ends are published separately rather than averaged into one number, and the provider's own best workload is never used as its score. Both would rank each plan on a different workload from its neighbour. Floor equal to ceiling is a measurement, not a placeholder: a plan metering one flat unit per method buys the same number of requests whatever is called, and on Solana only one mix is priced, so every row there reports a degenerate span.
- A plan that refuses the workload is absent from its tab, not ranked at zero, and one plan is absent from all four. Dwellir's Free plan buys 100,000 responses a day at one credit each, 3M simple reads a month, but it excludes eth_getLogs, which the dapp and indexer mixes call, and serves no trace or debug, and Dwellir serves no Solana. Its allowance is real and spends on none of the workloads this page asks about. Its paid plans are on bench 282.
- Not scored here: latency, reliability, archive depth, throughput ceilings and support. A large allowance behind a 25 requests per second cap serves a different application than the same allowance behind 300. The per-chain RPC pages measure the speed of these same endpoints.

## AI trading agents: what eight models earn net of the asset

- Category: Trading
- Metric: Alpha net of asset exposure (pct)
- Page: https://openchainbench.com/benchmarks/trading-agent-alpha
- JSON: https://openchainbench.com/api/stat/trading-agent-alpha
- Status: live
- Headline: gemini 3 pro chart leads alpha net of asset exposure at -11.4% (30d avg) across 8 ranked agents.

**Rankings (Alpha, 30d):**
1. gemini 3 pro chart: Alpha -11.4% (success 100.0%, sample 21)
2. grok 4 chart: Alpha -12.9% (success 100.0%, sample 21)
3. grok 4 vision: Alpha -13.4% (success 100.0%, sample 23)
4. opus 4.5 chart: Alpha -13.9% (success 100.0%, sample 21)
5. gpt-5.2 chart: Alpha -16.4% (success 100.0%, sample 21)
6. gemini 3 pro vision: Alpha -18.3% (success 100.0%, sample 23)
7. sonnet 4.5 vision: Alpha -26.9% (success 100.0%, sample 23)
8. gpt-5.2 vision: Alpha -31.0% (success 100.0%, sample 23)

**Methodology**:
- Source: Recall Labs' public competition API, no credential required. One pass an hour recomputes every figure from scratch, so the harness holds no state and a missed pass loses nothing. Results back to May 2025 are still served upstream, verified against the oldest round.
- Scope: the `aerodrome-spot-live` arena only, which is live spot trading on Base through Aerodrome with real money. One arena on purpose. Across Recall's other arenas the round length spans 11x, the funded capital spans ten orders of magnitude, the field runs from 6 to 64, and the instrument changes between spot, leveraged perpetuals and simulated money.
- Why one arena and not a pooled score: we built eight defensible aggregates of the pooled data and they disagree. Mean rank percentile against mean raw return share only 3 of the top 10 names, with a median move of 12 places and a maximum of 51 out of 67 agents. Whatever sat on top would be a property of the chosen normalisation, not of the agents.
- Headline: compounded return over an agent's funded rounds, minus the compounded return of a passive position at that agent's own regression beta to the asset over those same rounds. Higher is better and zero means the model added nothing beyond the exposure it held.
- Beta is measured per agent, not assumed, by regressing its round returns on the asset's return over the same windows. The measured betas run from 0.12 to 0.74, so a single blanket exposure assumption would flatter some agents and penalise others.
- A round with a zero profit figure is almost never a flat trade. Of the zero rows in this arena, 88 of 90 carry a portfolio value of zero, meaning the agent did not fund that round. Only funded rounds count. Treating them as zero-percent results drops the measured hit rate by eleven points and inflates each sample from about 22 rounds to 34.
- Eleven ended rounds publish ranks from 1 to 8 and no data at all, every portfolio value zero. The harness refuses to score a round without a real field, and publishes the count it refused as `trading_agent_rounds_skipped`.
- Roster age, published rather than implied: these eight agents were enrolled upstream on 2025-12-24 and 2026-01-14 and the field has not changed since. `trading_agent_roster_age_days` carries the gap so the page never reads as a statement about the current frontier. We cannot widen it either: the arena is allowlisted at eight places and Recall picks them.
- The roster changed once. Only agents with at least ten funded rounds are ranked, which selects the eight-model roster that 32 rounds share. A handful of other entries appear two or three times and are not averaged into the same table.
- The asset counterfactual comes from Coinbase's public ETH-USD daily closes, deliberately outside Recall, because a benchmark drawn from the same source as the thing it measures is circular. Where a round boundary has no candle the harness walks back up to five days, and a round with no price is skipped rather than scored against nothing.
- What this does not measure: Recall builds the agents. Their own description reads `Autonomous live spot trading agent built by Recall Labs, powered by` the model in question, so the prompt, the rebalancing and the execution are Recall's and are held constant. This is one harness interacting with each model, never a model's trading ability in the abstract.
- Agent names are declared, not verified. Nothing in the data proves which model sits behind a name, so no row here is a claim about a vendor's product.
- Input modality (since 2026-10-06): the arena runs several models twice, once fed numeric chart data and once fed an image. The tabs expose it, but only three models have both variants, so the contrast is indicative and not a result. The mean paired difference is 7.3 points with a standard deviation of 7.1 across those three.
- Significance, published rather than implied: the unit of observation is the ROUND, not the agent-round. The eight agents trade the same week, so their results are correlated and pooling every agent-round would treat one week as eight and overstate the confidence by roughly the square root of the roster. The harness averages alpha within each round first, then tests that series against zero, and publishes the t, the rounds held and the rounds the effect size needs.
- Separability: each pair of agents is compared on the rounds BOTH of them funded. The paired difference cancels the asset entirely, so this test needs no beta and no counterfactual and is the cleanest statement available about whether two agents differ. The count of pairs that clear |t|>2 is published; it is currently zero of 28.
- Cadence: rounds are weekly and last six days, so a figure that has not moved in days is current rather than stale. That holds only while the arena runs, so the harness also publishes the forward schedule as `trading_agent_scheduled_rounds`: rounds that have not ended yet. Zero means the experiment is over and this table is a closed record.
- Which return this is: the Return column compounds each round's percentage, a time-weighted return. It ignores money moved in or out between rounds, because the arena decides those and the agent does not, which is the standard way to judge a manager whose cash flows it does not control.
- That return is NOT the change in the wallet, and the gap can be large. Over this record opus 4.5 chart publishes -19.22 percent while its wallet went from 297.64 to 302.76 dollars, a gain of 1.7 percent, because capital was withdrawn along the way. Read the column as the trading record, not as the balance.
- Capital is small and did not hold still. Median portfolio value is a few hundred dollars per agent, but the largest-to-smallest ratio across an agent's own rounds runs from 1.3 to about 190, and half the roster is above 5. Published as `trading_agent_capital_ratio`, because gas is a fixed cost per swap: the same strategy drags far harder on a three-dollar wallet than on a three-hundred-dollar one, so for those agents the late rounds are not comparable with the early ones.
- Trade counts come from each agent's own upstream record, and are lifetime rather than per arena. They are not diluted: checked against each agent's round list, 35 to 37 of every agent's 32 to 34 completed rounds are this arena. A missing counter is published as missing rather than as zero, because zero would read as an agent that never trades.
- What the fee arithmetic assumes, and why it is not yet a finding: it charges the full portfolio to every trade. The real cost depends on the NOTIONAL of each trade, which this API does not serve. That figure is on-chain, and the upstream publishes each agent's wallet address, so every swap is independently checkable on Base. Until it is measured, treat the cost figure as an upper bound rather than an explanation.
- Liveness is published as a count rather than inferred from data age, because a weekly arena is legitimately six days stale most of the time while the site stops indexing a page whose data passes seven days. Tying the two together would deindex this page every week.
- What happens when the arena stops: Recall has retired arenas before, and this one will end eventually. The published figures stay valid as history, so they are not withdrawn; what changes is the tense. The page states the number of scheduled rounds and the age of the last one so a reader can tell a running experiment from a finished one without taking our word for it.

## Katana RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. BlockVectra: 113 ms (p99 336 ms, success 99.7%, sample 4319.75)
2. dRPC: 115 ms (p99 195 ms, success 99.1%, sample 4320.75)
3. Katana: 137 ms (p99 356 ms, success 100.0%, sample 4319.75)
4. Conduit: 139 ms (p99 260 ms, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Katana-scoped view of the same harness.
- Roster: every endpoint here answered a real `eth_getBlockByNumber` call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="katana"`. Provider coverage: 4 no-key endpoints.

## Tempo RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. dRPC: 57 ms (p99 220 ms, success 99.0%, sample 4319.75)
2. PublicNode: 84 ms (p99 326 ms, success 100.0%, sample 4320.75)
3. Tempo: 136 ms (p99 605 ms, success 100.0%, sample 4316.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Tempo-scoped view of the same harness.
- Roster: every endpoint here answered a real `eth_getBlockByNumber` call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="tempo"`. Provider coverage: 3 no-key endpoints.

## 0G RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. 0G Labs: 34 ms (p99 108 ms, success 98.8%, sample 4317.75)
2. PublicNode: 84 ms (p99 351 ms, success 100.0%, sample 4320.75)
3. dRPC: 135 ms (p99 479 ms, success 100.0%, sample 4317.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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the 0G-scoped view of the same harness.
- Roster: every endpoint here answered a real `eth_getBlockByNumber` call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="0g"`. Provider coverage: 3 no-key endpoints.

## Neo X RPC endpoints: free public URLs by latency

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/neox-rpc
- JSON: https://openchainbench.com/api/stat/neox-rpc
- Status: live
- Headline: Bane Labs (secondary) has the lowest median latency of the 2 free public Neo X RPC endpoints measured, 112 ms (p50, 24h, 3 regions).

**Rankings (p50, 24h):**
1. Bane Labs (secondary): 112 ms (p99 460 ms, success 100.0%, sample 4319.75)
2. Bane Labs: 112 ms (p99 459 ms, success 100.0%, sample 4320.75)

**Methodology**:
- Cadence: every 60 seconds per provider, from each of 3 probe regions (us-east Virginia, eu-west Amsterdam, sgp Singapore). Headline p50/p90/p99 aggregate across all 3 regions via Prometheus `avg(quantile_over_time(...))`; per-region breakdowns are first-class on this page via the region tabs.
- Payload: `{"jsonrpc":"2.0","id":<rotating>,"method":"eth_getBlockByNumber","params":["latest", false]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Neo X-scoped view of the same harness.
- Roster: every endpoint here answered a real `eth_getBlockByNumber` call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="neox"`. Provider coverage: 2 no-key endpoints.

## TAC RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. dRPC: 155 ms (p99 238 ms, success 99.1%, sample 4320.75)
2. TAC: 160 ms (p99 549 ms, 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. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the TAC-scoped view of the same harness.
- Roster: every endpoint here answered a real `eth_getBlockByNumber` call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="tac"`. Provider coverage: 2 no-key endpoints.

## ZIGChain RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. NodeStake: 86 ms (p99 97 ms, success 99.5%, sample 4318.75)
2. Stake and Relax: 101 ms (p99 385 ms, success 99.7%, sample 4315.75)
3. Polkachu: 128 ms (p99 259 ms, success 100.0%, sample 4317.75)
4. Numia: 130 ms (p99 223 ms, success 99.5%, sample 4317.75)
5. ZIGChain: 311 ms (p99 386 ms, success 100.0%, sample 4318.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the ZIGChain-scoped view of the same harness.
- Roster: every endpoint here answered a real Tendermint status call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="zigchain"`. Provider coverage: 5 no-key endpoints.

## Agoric RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. StakeAngle: 94 ms (p99 593 ms, success 100.0%, sample 4318.75)
2. Polkachu: 126 ms (p99 241 ms, success 100.0%, sample 4313.75)
3. Agoric: 236 ms (p99 544 ms, success 98.8%, sample 4313.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the Agoric-scoped view of the same harness.
- Roster: every endpoint here answered a real Tendermint status call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="agoric"`. Provider coverage: 3 no-key endpoints.

## CONX (ex-XPLA) RPC endpoints: free public URLs

- Category: RPCs
- Metric: RPC latency (ms)
- Page: https://openchainbench.com/benchmarks/xpla-rpc
- JSON: https://openchainbench.com/api/stat/xpla-rpc
- Status: live
- Headline: PublicNode posts the lowest RPC latency at 90 ms (p50, 24h) across 3 ranked providers.

**Rankings (p50, 24h):**
1. PublicNode: 90 ms (p99 290 ms, success 100.0%, sample 4321.75)
2. Polkachu: 124 ms (p99 242 ms, success 100.0%, sample 4318.75)
3. XPLA: 126 ms (p99 178 ms, success 100.0%, sample 4317.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the XPLA-scoped view of the same harness.
- Roster: every endpoint here answered a real Tendermint status call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="xpla"`. Provider coverage: 3 no-key endpoints.

## XRPL EVM RPC endpoints: free public URLs by latency

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

**Rankings (p50, 24h):**
1. Cumulo: 92 ms (p99 475 ms, success 99.9%, sample 4320.75)
2. Peersyst: 113 ms (p99 578 ms, success 100.0%, sample 4318.75)
3. Polkachu: 115 ms (p99 231 ms, success 99.1%, sample 4319.75)
4. ITRocket: 136 ms (p99 206 ms, success 99.9%, sample 4317.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":"status","params":[]}`. Plain HTTP POST, identical for every endpoint, no API key in any request. The request id rotates, but that does not guarantee a cache miss: many caches normalise `id` away. Measured 2026-10-08, fixed and rotating ids answer within 2 to 4 percent of each other.
- Latency measurement, call-result classification (`ok`, `http_err`, `jsonrpc_err`, `stale`, `timeout`) and the exclusion rules follow the cluster method documented on [rpc-capabilities](https://openchainbench.com/benchmarks/rpc-capabilities#methodology); this page is the XRPL EVM-scoped view of the same harness.
- Roster: every endpoint here answered a real Tendermint status call without a key on the 2026-10-07 sweep before being added to the probe matrix. An endpoint that needs a key, region-blocks us or rate-limits below the 60-second cadence is excluded rather than listed with an asterisk.
- Chain scope: every query on this page is pinned to `chain="xrplevm"`. Provider coverage: 4 no-key endpoints.

## Perp DEX leverage terms: room to liquidation and what is left

- Category: Trading
- Metric: Room to liquidation (pct)
- Page: https://openchainbench.com/benchmarks/perp-max-leverage-terms
- JSON: https://openchainbench.com/api/stat/perp-max-leverage-terms
- Status: live
- Awaiting samples.

**Methodology**:
- Cadence: every 5 minutes, on the perp-cohort-stats sweep. These are governance parameters, so they are read fresh rather than averaged, and every series is cleared each tick so a venue that lowers its maximum stops publishing the settings it no longer offers.
- Leverage selector: the default view puts each venue at its own maximum, which compares venues at different leverages and is not like for like. The fixed settings put every venue on the same leverage; a venue whose maximum is below the selected setting is absent from that view rather than shown at a leverage it does not offer.
- Markets: BTC and ETH only. They are the only two markets all five venues list, and the comparison means nothing across different assets.
- Room formula, every venue: (1/leverage - maintenance requirement - 2 x fee) x 100, every term a share of notional. Collateral lost is that room times the leverage, which is the same measurement in the unit venues quote among themselves.
- Gains and Nova, parameters: pairMaxLeverage, pairMinLeverage and getPairLiquidationParams by eth_call on each venue's Arbitrum diamond, Gains at 0xFF162c694eAA571f685030649814282eA457f169 and Nova at 0x1410FA3F87F6A6ea221E5D2aB608C23005eC34f3. The fee comes from the pair's fee group, word 9 of pairs() then word 0 of fees() at 1e10, the same read the perp-fees harness runs in production.
- Gains and Nova, pairs: four per venue. The standard BTC and ETH pairs 0 and 1 run 1.1x to 200x; the x500 degen pairs 300 and 313 have a minimum equal to their maximum, so 500x is their only legal setting, and each leverage tab shows whichever product can be opened at it. Nova serves the identical 493-pair registry, so the same indices are the same assets, checked against its own registry rather than assumed.
- Gains, checked against liquidations: percentProfit on the LimitExecuted log is the price move times leverage and nothing else, and our liquidation harness reproduces it on 120 of 120 real liquidations. Eleven liquidations on the two degen pairs give a median of 59.4 percent of collateral against the 60.0 percent this model predicts. The remaining gap is the borrowing fee, which accrues with holding time and is not a term at open.
- Gains, collateral returned: zero at every leverage. amountSentToTrader is 0 on all 27 liquidations found across every pair from 7.5x to 500x. The threshold says when a position closes, not what comes back.
- Papertrade: max leverage and the bust buffer from the instrument tuple on exchange.papertrade.xyz/state/trading. The buffer is a share of price and is an offset before the zero equity price, not the room itself: their documentation works the 1000x case and gives a move of about 0.052 percent, which is one tenth of a percent minus the buffer.
- Papertrade, checked against closes: its contract is unverified, so the event fields were identified against external truth rather than an ABI. The price field matches the live Hyperliquid mid under the per instrument factor; the leverage field caps at exactly 1000, the documented maximum; and under the resulting reading the predicted bust distance is never crossed on 384 adverse closes, the closest reaching 92 percent of it.
- Papertrade, collateral returned: zero. Their documentation calls crossing the bust price a hard bust that forfeits the full isolated margin even where a voluntary close immediately beforehand could return some equity. At 1000x that forgone equity is close to half the margin.
- dYdX: initialMarginFraction and maintenanceMarginFraction from indexer.dydx.trade/v4/perpetualMarkets, both published per market, with the maximum leverage the reciprocal of the initial fraction. Neither venue's payload carries a fee we can read, so the dYdX and Hyperliquid rows carry no fee legs and their room is the parameter ceiling rather than a fee inclusive figure.
- Hyperliquid: maxLeverage from the info meta endpoint. The maintenance requirement is not in the payload; its documentation fixes it at half the initial requirement at maximum leverage, so this row alone has a derived input and its share returned reads 50 percent at its maximum on every market by construction.
- No row is ranked. More room before liquidation comes from holding back less maintenance margin, and the venue that holds back least is the one that keeps everything when it fires. A single ranking on this metric would reward that, whichever venue came out on top, so every row publishes without a rank.
- Excluded: funding, borrowing, and the liquidation spread. All three move the real trigger closer than the figures here. A position held for days is liquidated by carry long before the price reaches these levels.
- Cohort: perp venues in the harness that publish enough to compute the figures on BTC and ETH, 4 as of 2026-10-12. Venues that advertise high leverage but publish no maintenance parameter we can read are absent rather than estimated.

## Fastest private Ethereum WebSocket push, per-block race across keyed RPC providers

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/ethereum-rpc-ws
- JSON: https://openchainbench.com/api/stat/ethereum-rpc-ws
- Status: live
- Headline: Alchemy pushes the most Ethereum blocks first over WebSocket, 63.2% of those it received; GetBlock follows at 28.4% (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. Alchemy: 63.2% (p99 63.2%, success 100.0%, sample 3588.25)
2. GetBlock: 28.4% (p99 28.4%, success 100.0%, sample 3588.25)
3. Quicknode: 8.25% (p99 8.25%, success 100.0%, sample 3588.25)
4. Dwellir: 0.20% (p99 0.20%, success 99.7%, sample 3579.24)
5. Chainstack: 0.028% (p99 0.028%, success 99.9%, sample 3583.24)

**Methodology**:
- Race, not latency: all providers wait for the same block, so only who delivers it first belongs to them. The published figure is each provider's share of the blocks it received that it delivered first in its region, pooled over 24h. A provider at 0% received the blocks, never first.
- One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
- Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
- Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its share of wins says.
- GetBlock issues one WebSocket token per chain per region, so its three cells are distinct endpoints rather than one URL probed from three places.
- Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
- Alchemy joined this race on 13 November 2026. Its endpoint bills a subscription by the byte it pushes, so the probe holds a monthly byte budget per region for Alchemy and closes its sockets when the budget is spent; the HTTP rows on the same key are unaffected. A month in which the budget trips shows Alchemy with fewer blocks seen, which the coverage column makes visible.
- Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

## Fastest private Base WebSocket push, per-block race across keyed RPC providers

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/base-rpc-ws
- JSON: https://openchainbench.com/api/stat/base-rpc-ws
- Status: live
- Headline: Quicknode pushes the most Base blocks first over WebSocket, 68.1% of those it received; Dwellir follows at 23.1% (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. Quicknode: 68.1% (p99 68.1%, success 100.0%, sample 216014)
2. Dwellir: 23.1% (p99 23.1%, success 100.0%, sample 216035)
3. Chainstack: 6.44% (p99 6.44%, success 99.8%, sample 215618)
4. GetBlock: 2.13% (p99 2.13%, success 100.0%, sample 216024)
5. Alchemy: 0.32% (p99 0.32%, success 100.0%, sample 216005)

**Methodology**:
- Race, not latency: all providers wait for the same block, so only who delivers it first belongs to them. The published figure is each provider's share of the blocks it received that it delivered first in its region, pooled over 24h. A provider at 0% received the blocks, never first.
- One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
- Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
- Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its share of wins says.
- GetBlock issues one WebSocket token per chain per region, so its three cells are distinct endpoints rather than one URL probed from three places.
- Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
- Alchemy joined this race on 13 November 2026. Its endpoint bills a subscription by the byte it pushes, so the probe holds a monthly byte budget per region for Alchemy and closes its sockets when the budget is spent; the HTTP rows on the same key are unaffected. A month in which the budget trips shows Alchemy with fewer blocks seen, which the coverage column makes visible.
- Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

## Fastest private BNB Chain WebSocket push, per-block race across keyed RPC providers

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/bnb-rpc-ws
- JSON: https://openchainbench.com/api/stat/bnb-rpc-ws
- Status: live
- Headline: Quicknode pushes the most BNB Chain blocks first over WebSocket, 69.8% of those it received; Alchemy follows at 22.4% (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. Quicknode: 69.8% (p99 69.8%, success 100.0%, sample 95998.3)
2. Alchemy: 22.4% (p99 22.4%, success 100.0%, sample 95987.3)
3. GetBlock: 5.24% (p99 5.24%, success 100.0%, sample 95991.3)
4. Chainstack: 1.64% (p99 1.64%, success 100.0%, sample 95991.3)
5. Dwellir: 0.88% (p99 0.88%, success 100.0%, sample 95962.3)

**Methodology**:
- Race, not latency: all providers wait for the same block, so only who delivers it first belongs to them. The published figure is each provider's share of the blocks it received that it delivered first in its region, pooled over 24h. A provider at 0% received the blocks, never first.
- One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
- Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
- Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its share of wins says.
- GetBlock issues one WebSocket token per chain per region, so its three cells are distinct endpoints rather than one URL probed from three places.
- Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
- Alchemy joined this race on 13 November 2026. Its endpoint bills a subscription by the byte it pushes, so the probe holds a monthly byte budget per region for Alchemy and closes its sockets when the budget is spent; the HTTP rows on the same key are unaffected. A month in which the budget trips shows Alchemy with fewer blocks seen, which the coverage column makes visible.
- Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

## Fastest private Polygon WebSocket push, per-block race across keyed RPC providers

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/polygon-rpc-ws
- JSON: https://openchainbench.com/api/stat/polygon-rpc-ws
- Status: live
- Headline: Quicknode pushes the most Polygon blocks first over WebSocket, 85.8% of those it received; GetBlock follows at 13.2% (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. Quicknode: 85.8% (p99 85.8%, success 100.0%, sample 28810)
2. GetBlock: 13.2% (p99 13.2%, success 99.7%, sample 28711)
3. Alchemy: 0.99% (p99 0.99%, success 100.0%, sample 28808)
4. Chainstack: 0.13% (p99 0.13%, success 100.0%, sample 28804)
5. Dwellir: 0.045% (p99 0.045%, success 100.0%, sample 28798)

**Methodology**:
- Race, not latency: all providers wait for the same block, so only who delivers it first belongs to them. The published figure is each provider's share of the blocks it received that it delivered first in its region, pooled over 24h. A provider at 0% received the blocks, never first.
- One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
- Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
- Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its share of wins says.
- GetBlock issues one WebSocket token per chain per region, so its three cells are distinct endpoints rather than one URL probed from three places.
- Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
- Alchemy joined this race on 13 November 2026. Its endpoint bills a subscription by the byte it pushes, so the probe holds a monthly byte budget per region for Alchemy and closes its sockets when the budget is spent; the HTTP rows on the same key are unaffected. A month in which the budget trips shows Alchemy with fewer blocks seen, which the coverage column makes visible.
- Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

## Fastest private HyperEVM WebSocket push, per-block race across keyed RPC providers

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/hyperliquid-rpc-ws
- JSON: https://openchainbench.com/api/stat/hyperliquid-rpc-ws
- Status: live
- Headline: Chainstack pushes the most HyperEVM blocks first over WebSocket, 58.2% of those it received; Quicknode follows at 32.2% (24h) across 4 ranked providers.

**Rankings (p50, 24h):**
1. Chainstack: 58.2% (p99 58.2%, success 99.9%, sample 43912.7)
2. Quicknode: 32.2% (p99 32.2%, success 100.0%, sample 43938.6)
3. Dwellir: 8.34% (p99 8.34%, success 100.0%, sample 43936.6)
4. Alchemy: 0.10% (p99 0.10%, success 100.0%, sample 43925.7)

**Methodology**:
- Race, not latency: all providers wait for the same block, so only who delivers it first belongs to them. The published figure is each provider's share of the blocks it received that it delivered first in its region, pooled over 24h. A provider at 0% received the blocks, never first.
- One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
- Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
- Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its share of wins says.
- Quicknode serves this chain's WebSocket on a separate /nanoreth path rather than the /evm path its HTTP endpoint uses. GetBlock completed a handshake only from Frankfurt, so it is raced from eu-west alone.
- Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
- Alchemy joined this race on 13 November 2026. Its endpoint bills a subscription by the byte it pushes, so the probe holds a monthly byte budget per region for Alchemy and closes its sockets when the budget is spent; the HTTP rows on the same key are unaffected. A month in which the budget trips shows Alchemy with fewer blocks seen, which the coverage column makes visible.
- Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

## Fastest private Arc WebSocket push, per-block race across keyed RPC providers

- Category: RPCs
- Metric: First to push (pct)
- Page: https://openchainbench.com/benchmarks/arc-rpc-ws
- JSON: https://openchainbench.com/api/stat/arc-rpc-ws
- Status: live
- Headline: Quicknode pushes the most Arc blocks first over WebSocket, 76.9% of those it received; Chainstack follows at 18.4% (24h) across 5 ranked providers.

**Rankings (p50, 24h):**
1. Quicknode: 76.9% (p99 76.9%, success 100.0%, sample 85269.6)
2. Chainstack: 18.4% (p99 18.4%, success 100.0%, sample 85285.6)
3. GetBlock: 6.21% (p99 6.21%, success 66.7%, sample 56874.7)
4. Dwellir: 0.37% (p99 0.37%, success 100.0%, sample 85267.6)
5. Alchemy: 0.28% (p99 0.28%, success 100.0%, sample 85305.6)

**Methodology**:
- Race, not latency: all providers wait for the same block, so only who delivers it first belongs to them. The published figure is each provider's share of the blocks it received that it delivered first in its region, pooled over 24h. A provider at 0% received the blocks, never first.
- One socket per provider per region, eth_subscribe(newHeads), opened for the same ten minutes of every hour across the whole cohort and closed with the window. Every frame is timestamped on receipt. The window is aligned to the clock rather than to each connection, because a race only means something if every provider is listening to the same blocks.
- Sampled rather than continuous since 2026-10-17, and the reason is ours: a permanent subscription on nine chains pushed about 138 million messages a month per provider against 583 thousand HTTP probes, and one vendor reached its monthly limit. The three fastest chains left the arm and the rest listen a sixth of the time. Racing a provider until its account is exhausted would remove it from nine other pages.
- Reconnections are a published result, not an implementation detail: a provider that drops twice in two minutes is unusable to a subscriber whatever its share of wins says.
- GetBlock does not offer this chain from Singapore, so it is raced from us-east and eu-west only and its Singapore column is empty by provision rather than by failure.
- Validation Cloud is listed on the HTTP cohorts of this chain but not here: its WebSocket endpoint refuses the upgrade in all three regions (`websocket: bad handshake`), so there is nothing to race. Measured over 3h on 2026-10-17: 542 reconnection attempts, zero frames. The row returns when the endpoint opens.
- Alchemy joined this race on 13 November 2026. Its endpoint bills a subscription by the byte it pushes, so the probe holds a monthly byte budget per region for Alchemy and closes its sockets when the budget is spent; the HTTP rows on the same key are unaffected. A month in which the budget trips shows Alchemy with fewer blocks seen, which the coverage column makes visible.
- Same keyed endpoints as the HTTP cohort on this chain, same keys, same three regions. Keys live in the probe environment, never in this repository. Plan tiers are disclosed on the HTTP cohort's methodology.

## Best DEX aggregator by quote output: who actually gives you more

- Category: Aggregators
- Metric: Quote shortfall (bp)
- Page: https://openchainbench.com/benchmarks/evm-quote-output
- JSON: https://openchainbench.com/api/stat/evm-quote-output
- Status: live
- Headline: ParaSwap posts the lowest quote shortfall at 0.38 bps (p50, 24h) across 5 ranked quote sources.

**Rankings (Shortfall, 24h):**
1. ParaSwap: Shortfall 0.38 bps, p90 3.08 bps, p99 30.9 bps (success 100.0%, sample 4319.75)
2. Nordstern: Shortfall 1.19 bps, p90 7.41 bps, p99 55.4 bps (success 100.0%, sample 3574.62)
3. KyberSwap: Shortfall 1.62 bps, p90 8.86 bps, p99 31.6 bps (success 100.0%, sample 4315.75)
4. Uniswap: Shortfall 4.10 bps, p90 10.1 bps, p99 52.6 bps (success 100.0%, sample 3599.62)
5. Mobula: Shortfall 13.6 bps, p90 21.4 bps, p99 64.9 bps (success 100.0%, sample 3595.62)

**Methodology**:
- The comparison is within a tick, never across them. Every provider that supports the pair is fired in parallel on the same 60 second tick, and each is scored against the best output of that tick. Measured 2026-10-19 across five probes a minute apart, the market drifted 30 to 37 bps while the field sat inside 25, so a cross-tick comparison would measure the market rather than the provider.
- Zero means the provider held the best quote of that tick. The published figure is the median over 24 hours, not the mean, so one outlying round cannot move a row. The near-best column counts the ticks a provider came within half a basis point of the best, which is the tiebreaker when medians sit within a basis point of each other. Several providers can clear it in the same tick, so the column does not sum to 100.
- Declared fees get their own column and are measured, not quoted: the figure is read out of the provider's own quote response on every tick. Only some declare one, and the column is blank for the rest. Compare it against the shortfall beside it rather than assuming they match, because they need not: a declared fee is what the provider takes, the shortfall is what the route and the fee together cost. A provider that declares nothing publishes no fee, which is not the same as charging nothing.
- Not every row is an aggregator. CoW and Bebop are RFQ or batch-auction venues and LI.FI is a cross-chain relayer, so all three are listed with their numbers and kept out of the ranking. Route quotes Robinhood Chain alone and is kept out of the all-chains order for the same reason; its own tab carries the comparison.
- An RFQ quote is not a router quote. A market maker prices its own spread and its settlement into the number it returns, and a small clip pays for both in full: Bebop gives up around a hundred basis points on a $1,200 swap, and the figure barely moves between chains whose gas differs by orders of magnitude, so it is the spread and not the gas. Both RFQ rows are listed and neither is ranked.
- Gas is not subtracted yet. KyberSwap reports it in USD, ParaSwap in wei, Nordstern in gas units, and the USD figures of three providers on the same pair at the same block differ by a factor of 3.5. Until gas is computed on our side rather than theirs, this page measures gross output.
- Absent and why: 1inch requires a business account we do not have, OKX requires credentials not yet issued, Odos has published no volume for 30 days and its API returns 530, OpenOcean serves our probes a Cloudflare challenge, Enso's free-plan credits are exhausted, and 0x answers 403 You cannot consume this service on a key its own notes record as already replaced once. None of them is excluded on performance.
- Six pairs across five chains, one per 60 second tick, from us-east, eu-west and Singapore. Output does not vary meaningfully by region, measured at a 4.24 bps median spread against a market that drifts 30 to 37, so the regional split is a check on the probe rather than a dimension of the result.

## Crypto price API accuracy: how far each feed sits from the exchange price

- Category: Aggregators
- Metric: Price gap (bp)
- Page: https://openchainbench.com/benchmarks/price-api-accuracy
- JSON: https://openchainbench.com/api/stat/price-api-accuracy
- Status: live
- Headline: Bitculator posts the lowest price gap at 8.46 bps (p50, 24h) across 4 ranked price APIs.

**Rankings (Median gap, 24h):**
1. Bitculator: Median gap 8.46 bps, p90 28.4 bps, p99 67.2 bps (success 100.0%, sample 2592.9)
2. CoinGecko: Median gap 10.7 bps, p90 35.5 bps, p99 82.2 bps (success 99.5%, sample 12883.5)
3. Mobula: Median gap 15.3 bps, p90 64.6 bps, p99 491 bps (success 100.0%, sample 25920)
4. CoinPaprika: Median gap 15.7 bps, p90 54.4 bps, p99 128 bps (success 100.0%, sample 648.226)

**Methodology**:
- Reference: the median of the Coinbase (USD), Kraken (USD) and Binance mids, refreshed every five seconds, Binance's USDT books converted at the Coinbase and Kraken USDT/USD mid. An asset is scored only when two venues priced it (the median of two is their mean), against the snapshot nearest the answer's arrival, within six seconds. A poll with no reference that close, or lost in our proxy before any HTTP status, is counted apart and never against the provider.
- The headline is the median absolute gap over 24 hours, pooled across the assets a provider serves, in basis points. Percentiles are read from a histogram with half basis point buckets up to 15, so a median is exact to within half a basis point. The asset tabs give the same figure per coin, which is the like for like comparison. The bias column is the mean signed gap: positive means the API prints above the market.
- Each provider is polled on the cadence its quota allows: every 30 seconds to every 20 minutes. Fewer polls give fewer samples of the same distribution, not a different score, and the Samples column shows how many answers each row rests on.
- Price age comes from the provider's own last-updated stamp, read at the moment the answer arrived. A provider that publishes no stamp shows a dash, which does not mean its price is fresh.
- Serialized is an on-chain DEX price feed and is listed unranked. It prices WETH, wSOL, WBNB and LINK in their pools. BTC is left out because WBTC trades 15 to 20 bps under BTC, measured on Binance's WBTC/BTC book and on a KyberSwap quote, and scoring it against BTC would charge it for the wrapper's discount. Serialized does not index Avalanche.
- Mobula is addressed by its numeric asset id. Looked up by name, Bitcoin resolved to a different token priced at 9e-14 USD in three of 66 internal polls, a lookup artefact this page does not charge to anyone.
- CoinGecko is read through its keyless public API, reached through a proxy because it answers 429 to the host's shared address. Paid CoinGecko plans may refresh faster than the keyless tier measured here. CoinPaprika is read keyless at 27 calls an hour, under its 60 an hour and 25,000 a month limits. POL was measured internally and left out: one ranked provider does not list it.
- Absent and why: CoinMarketCap and CoinDesk (formerly CryptoCompare) require an API key we have not been issued. Neither is excluded on performance.
- One probe region, the OpenChainBench host in France. The gap does not depend on where the request comes from the way latency does, but the reference and the answer are both read from there.

## Cheapest embedded wallet provider for each app size, from published prices

- Category: Wallets
- Metric: Monthly cost for a consumer app at 10,000 users (usd)
- Page: https://openchainbench.com/benchmarks/wallet-cost
- JSON: https://openchainbench.com/api/stat/wallet-cost
- Status: live
- Headline: Reown posts the lowest monthly cost for a consumer app at 10,000 users at $214 (latest value) across 11 ranked vendors, measured on Consumer app, 5 transactions a user, 10,000 users.

**Rankings (Monthly bill, 24h):**
1. Reown: Monthly bill $214 (success 100.0%, sample 4)
2. thirdweb: Monthly bill $234 (success 100.0%, sample 4)
3. Openfort: Monthly bill $261 (success 100.0%, sample 4)
4. Web3Auth: Monthly bill $384 (success 100.0%, sample 4)
5. Magic: Monthly bill $399 (success 100.0%, sample 4)
6. Circle: Monthly bill $435 (success 100.0%, sample 4)
7. Coinbase CDP: Monthly bill $485 (success 100.0%, sample 4)
8. Privy: Monthly bill $499 (success 100.0%, sample 4)
9. Dynamic: Monthly bill $499 (success 100.0%, sample 4)
10. Para: Monthly bill $500 (success 100.0%, sample 4)
11. Portal: Monthly bill $6,699 (success 100.0%, sample 4)

**Methodology**:
- Cohort. 14 vendors with a self-serve price on a public page: Privy, Dynamic, Turnkey, Web3Auth, Magic, Para, Coinbase CDP, thirdweb, Openfort, Circle, Reown, ZeroDev, Crossmint and Portal. Alchemy, Dfns, Fireblocks, Sequence and Particle Network are listed below with the reason they cannot be priced. Portal was listed as unpriceable until 2026-10-29, which was wrong: its Start-Up plan is published.
- Profiles. A consumer app whose users send 5 transactions a month and 20% of whom are new each month, an active app at 25 and 10%, a trading app at 100 and 5%. One wallet per user. A transaction is one signature followed by one broadcast; sign-in signatures are not counted, and Magic says they are not billed.
- Units. Each vendor's own meter is written as a linear function of the app: Privy and Magic bill active users plus signatures, Turnkey signatures, Coinbase CDP and Openfort wallet operations (1 per new wallet, 2 per transaction, from their own tables), ZeroDev credits (10 per signature, 20 per UserOp, so 30 per transaction), and the rest active users or active wallets.
- An active user is not one thing. Privy counts a user with a session in the last 30 days, Dynamic a login or a wallet created that month, Web3Auth and thirdweb a login, Magic a wallet accessed through its SDK, Para a user authenticated or created, Circle a wallet that made an on-chain transaction. Every user in these profiles transacts, so all of them count everyone.
- Plans. Each plan's fee, what it includes and its overage are applied as published. Graduated rates (Circle, thirdweb) bill each band at its own rate. A plan that stops at a size (Para's free 1,200 users, Reown's free 500, Turnkey's 2,000 wallets) cannot serve above it. Turnkey's limit counts every wallet an organisation holds while this model counts one month's users, so a growing app reaches it sooner than the calculator shows. A size past the last published price is a quote and is not ranked.
- Readings. Where a page can be read two ways the catalogue says which reading is priced and the calculator badges the plan. Privy's $2,000 pay-as-you-go base is priced alone, though its $499 Scale fee may also apply, and at exactly 10,000 users Privy is priced on Scale ($499) because pay-as-you-go starts above 10,000, though its Scale card reads 2,500 to 9,999; the other reading is $2,000. Turnkey's $99 Pro fee is priced as a floor the per-signature charges count against.
- Openfort's operation table gives 1 per wallet created and 2 per transaction, but its own simulator also adds 2 per active user; on that reading its bill is higher and it can drop a place, as the findings spell out for the 10,000-user consumer view. ZeroDev's 30 credits a transaction assumes each transaction is one signature and one UserOp. thirdweb's bands above 100,000 users are priced band by band.
- Openfort's Free plan is priced as stopping at 2,000 operations, as its FAQ states (HTTP 402), though its plan card offers $0.01 per operation once a payment method is added. Portal's wallet overage is priced every month, and a new wallet as two operations (Generate and Backup).
- Vendors' own exclusions are honoured. Reown says exchanges, custodians, payments, gaming and merchant platforms need a custom plan, so its self-serve price is not offered on the trading profile.
- Left out. Gas and gas-sponsorship surcharges (thirdweb 2.5% on mainnet, Openfort 10% or 5%, ZeroDev 8%), SMS fees, extra seats, annual discounts, Circle's USDC rebate, and Privy's $1M monthly transaction volume threshold. Features a production app may need are not priced: removing thirdweb branding needs its $499 Scale plan, and custom domains are Enterprise-only at several vendors.
- Any size, not only three. The table prices 1,000, 10,000 and 100,000 users because a metric needs a fixed label. The calculator prices any size from 100 to 1,000,000 from a curve the same harness emits, with a point at every tier boundary, cap, quote threshold and plan crossover. Between two points every bill is a straight line, so the slider is exact, not smoothed.
- Verification. A second implementation, written in another language from the catalogue's prose rather than the harness code, re-prices every curve point and 1,260,000 random app sizes, and agrees on the bill to the cent and on the plan in every case. `pnpm validate` re-runs it on an 84,000-size sample on every change, and refuses a curve built from a different catalogue.
- Freshness. Six of the first thirteen pages measured return a new body on every request while their prices stand still, so the harness hashes only the visible lines that carry a dollar figure or a number beside a billing word. A change that holds for six hours raises an alert, and a maintainer re-reads the page and corrects the catalogue. The page shows the catalogue date.

## Answers (42 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 181.4 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 50.1 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 120.9 min after the first outcome proposal reaches UMA's oracle, with the slowest 1% taking 238.8 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.012% of notional all in (Socket Protocol, p50 over 24h) and the most expensive at 0.75%, 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 90 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.84% (24h) versus 2.50% 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.025% worst case deviation (p99, 24h) versus 0.24% 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 90 ms p50, Manifold at 6.50 s 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, 90 ms p50) or Kalshi (documented API contract, CFTC-regulated). For dashboards and research: Manifold (500 req/min, explicit bot welcome, 6.50 s p50 origin) or Kalshi (most stable docs). Current latency leader across the cohort: Polymarket at 90 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 40 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 78 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 27 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: dRPC is currently the fastest free Hyperliquid RPC at 67 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 75 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 32 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 18.8% (median validator net yield, 24h) across the 15 chains OpenChainBench measures live; the lowest is Sui at 1.22%. 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 11.3% 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: Stellar currently posts the lowest median native transfer fee at $0.0000013, 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 77 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: Ink added $305.18M 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 476 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: Codex currently posts the lowest head lag at 0.03 s (p50, 24h) across Mobula, Codex and GeckoTerminal on Base, BNB Chain and Solana, measured live by OpenChainBench from 3 regions.

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

- Page: https://openchainbench.com/answers/which-crypto-price-api-is-the-most-accurate
- Benchmark: https://openchainbench.com/benchmarks/price-api-accuracy
- Answer: Bitculator currently prints closest to the exchange price, a median gap of 8.46 bps over 24h on BTC, ETH, SOL, BNB, XRP, ADA, DOGE, AVAX and LINK, scored by OpenChainBench against the Coinbase, Kraken and Binance mid of the same moment.

### 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: Securitize has the lowest price to fees of the 61 DeFi tokens OpenChainBench tracks, at 0.230x: 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 84.9% 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: PublicNode currently posts the tightest priority fee prediction at 0.990 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 $6.38B 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 $26.8K 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: SUI reaches finality at 0.25 s (p50, 24h), the lowest settlement time measured across 18 chains by OpenChainBench, each against its own finality rule.

### 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 92 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.0039% (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.091%. 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: AVNT trades at the lowest price to fees among 13 perp DEX tokens, at 1.424x: 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.0019% (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 $26.8K on the last complete UTC day, measured by OpenChainBench from Hyperliquid's public per-builder daily fills feed across all 109 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