prod release: batch 1 GEO (infobox, publisher.json, citation meta, immutable snapshots, 7 answers)

answers/alchemy-vs-quicknode-vs-infura-latency.yml

@@ -0,0 +1,43 @@
+slug: alchemy-vs-quicknode-vs-infura-latency
+question: "Alchemy vs QuickNode vs Infura, which has the lowest RPC latency in 2026?"
+short_answer: |
+  {{best_name}} currently leads the keyed free-tier RPC leaderboard at {{best_p50}} p50 latency (24h avg), measured live from three regions by OpenChainBench against the keyed free tiers of Alchemy, QuickNode, Infura, Chainstack, Ankr and Helius on the same eth_getBlockByNumber probe.
+
+benchmark: rpc-keyed-latency
+
+intro: |
+  Every dApp that outgrows the no-key public RPCs asks the same question next: which paid free-tier provider actually delivers the fastest response, from which region, and at what success rate. Vendor blog posts recite selective numbers with no independent probe. Chainstack quotes its own p50, Alchemy quotes its own p99, and none disclose regional variance or measurement methodology in enough detail to reproduce. This page answers the head-to-head that developers actually search for: which of Alchemy, QuickNode and Infura wins today, measured live, from three regions, using the same call. OpenChainBench probes eth_getBlockByNumber every 60 seconds against each provider's signup-gated free tier from us-east, eu-west and singapore, records the round-trip latency only for successful responses, and publishes the full leaderboard with QuickNode, Alchemy, Helius, Chainstack, Ankr and Infura ranked side by side.
+
+methodology: |
+  Every 60 seconds the harness fires the identical JSON-RPC POST `{"jsonrpc":"2.0","method":"eth_getBlockByNumber","params":["latest",false]}` against each provider's free-tier endpoint from three Railway replicas (us-east Virginia, eu-west Amsterdam, sgp Singapore). Latency is a client-side time.Now() delta around the round-trip, published to Prometheus as both a gauge and a histogram with buckets 50ms to 10s. p50/p90/p99 are computed via `quantile_over_time` over the last 24 hours per provider per region and averaged across regions for the headline. Only successful calls (HTTP 200 + non-empty result) enter the latency distribution, so a mostly failing provider never posts a spuriously fast p50 out of its rare successes. The Success column pairs every latency figure with the ok-rate over the same window, and providers below 5% success are pinned as unresponsive.
+
+limitations:
+  - "Free-tier probe only. Paid tiers have different rate limits, priority queues and archive access; the numbers here do not translate to paid usage. The keyed free tier is a lower bound on paid tier performance because paid tiers get more capacity, but variance can go either way at p99."
+  - "Latency is conditional on success. A provider that fails 40% of calls but returns the successes fast will show a fast p50 with a low Success column. Read both columns together before ranking."
+  - "Regional coverage varies by provider. Some vendors terminate close to their control plane and lose 40 to 80 ms when probed from a distant region. The per-region breakdown at the top of the bench page shows the geography-dependent leader."
+  - "No archive workload here. This bench measures head-of-chain read latency; archive queries (eth_getBalance at (head, 5M)) are on the sibling bench openchainbench.com/benchmarks/rpc-capabilities."
+
+faq:
+  - q: "Which free-tier RPC provider is fastest right now, Alchemy, QuickNode or Infura?"
+    a: "{{best_name}} leads at {{best_p50}} p50 (24h avg) on the free-tier keyed leaderboard measured across three regions. The full ranking including QuickNode, Alchemy, Helius, Chainstack, Ankr and Infura re-sorts every 60 seconds against fresh Prometheus samples."
+  - q: "Why does Infura sit lower on this leaderboard than Alchemy or QuickNode?"
+    a: "Infura's free-tier throughput has degraded in 2026 due to daily credit brownouts that turn into 429 responses. Because latency is only recorded on successful calls, Infura's p50 looks acceptable in isolation but the Success column reveals sub-95% ok-rate on the free tier. QuickNode and Alchemy pair fast latency with 99.9%+ success, which is why they sit above Infura in a fair ranking."
+  - q: "Are these numbers different from what Alchemy or QuickNode publish on their own marketing pages?"
+    a: "Yes. Every vendor cherry-picks the region and percentile that flatters its own footprint. This benchmark uses one identical call, three fixed regions, one 60s cadence, and publishes every provider under the same rules. That is why it produces cross-vendor rankings a vendor marketing page cannot."
+  - q: "Does this cover Chainstack, Ankr and Helius too?"
+    a: "Yes. The full leaderboard measures QuickNode, Alchemy, Helius (Solana keyed), Chainstack, Ankr and Infura under identical conditions. The head-to-head focus of this page is Alchemy vs QuickNode vs Infura because that is the highest-search-volume triangle, but the bench page ranks all six."
+  - q: "How is Helius even in this ranking, it is a Solana provider?"
+    a: "Helius offers keyed EVM-compatible endpoints for a subset of chains alongside its Solana product. The leaderboard measures Helius on the chains where it exposes a compatible eth_getBlockByNumber-style API. Cross-VM comparability is preserved because every provider is probed with the same call, and the per-chain tab surfaces where each provider actually competes."
+  - q: "Which region wins per provider?"
+    a: "QuickNode's mesh keeps its US-East p50 tight; Alchemy leads in EU-West on the majors; Chainstack has the best Singapore numbers on BNB and Polygon. The per-region breakdown at the top of the bench page shows the geography-dependent leader instead of hiding it in the cross-region average."
+  - q: "How often is the leaderboard refreshed?"
+    a: "Every 60 seconds the harness probes each provider from every region, publishes rpc_latency_milliseconds to Prometheus, and the page reads a 24h rolling average. Because the Prom recording rules aggregate every 30s the leaderboard on screen re-orders within a minute of any provider changing performance envelope."
+
+related:
+  - which-crypto-price-api-is-the-fastest
+  - which-l1-has-the-fastest-finality
+  - which-solana-rpc-lands-the-most-transactions
+
+seo_title: "Alchemy vs QuickNode vs Infura RPC latency, live 2026"
+seo_description: "{{best_name}} leads at {{best_p50}} p50 (24h avg) on the free-tier keyed RPC leaderboard. Alchemy, QuickNode, Infura, Chainstack, Ankr and Helius ranked live from three regions by OpenChainBench."
+status: live

answers/best-rpc-for-indexer.yml

@@ -0,0 +1,41 @@
+slug: best-rpc-for-indexer
+question: "Which RPC is best for indexers and high-throughput read workloads in 2026?"
+short_answer: |
+  {{best_name}} currently leads the free-tier keyed RPC leaderboard at {{best_p50}} 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.
+
+benchmark: rpc-capabilities
+
+intro: |
+  Indexer workloads have a different failure mode from user-facing dApps. A subgraph or a custom indexer runs continuous eth_getLogs and eth_getBlockReceipts against a chain's history, hits archive-depth constraints on deep queries, and lives or dies by p99 stability rather than p50 headline latency. This page answers the specific question every indexer developer eventually asks: which RPC provider is actually built for high-read workloads, factoring in latency tail, method availability, archive depth and success rate. OpenChainBench probes the multi-chain footprint every 60 seconds and publishes both the flat latency leaderboard and the archive-depth matrix (300 blocks, 7200 blocks, 216k blocks, 1.3M blocks, 5M blocks) side by side so an indexer can pick on the axis that matters for its query pattern.
+
+methodology: |
+  The head-latency leaderboard is the same eth_getBlockByNumber probe every 60 seconds from three Railway replicas. The archive-depth matrix is a separate probe running every 5 minutes: eth_getBalance at (head, depth) for depth in {300, 7200, 216000, 1300000, 5000000}. rpc_archive_depth_supported{provider, chain, depth} is 1 when the response is non-pruned, 0 otherwise. The depths cover Geth's default pruned cap (5760 blocks), 1 month, 6 months, and full genesis-era archive. Success rate is computed as ok-rate over total-rate on the same window; providers under 5 percent success drop from the ranking and get pinned as unresponsive.
+
+limitations:
+  - "eth_getLogs is not the head-of-chain probe used here. This ranking uses eth_getBlockByNumber for the latency axis and eth_getBalance for the archive axis. Real indexer workloads issue eth_getLogs with topic filters and can exercise different code paths inside a provider's stack. The latency and archive leaderboards are correlated with but not identical to eth_getLogs performance."
+  - "Free-tier keyed and no-key. This ranks the two tiers a small-to-medium indexer would pick from. Paid enterprise plans get more capacity and priority queues; they are outside the free-and-keyed scope of this bench."
+  - "Archive depth is a binary support signal, not a latency figure. A provider that returns pruned responses at 5M block depth appears with a 0 in the matrix; a provider that returns non-pruned data with a 6-second latency also appears with a 1. Indexers doing deep historical scans should read the matrix and the sibling archive-latency notes together."
+  - "Chain coverage varies. Not every provider supports every chain. The multi-chain average rewards universal providers; the per-chain tab exposes the chain-specific leader."
+
+faq:
+  - q: "Which RPC provider is best for a subgraph or custom indexer?"
+    a: "{{best_name}} leads the head-latency leaderboard at {{best_p50}} p50 (24h). For indexers the ranking that matters is the intersection of the latency leaderboard and the archive-depth matrix: a provider that wins latency but fails at 5M depth is not indexer-viable. The bench page surfaces both, and the head-to-head leader among indexer-viable providers is the answer."
+  - q: "Why does eth_getBlockByNumber matter for indexers when the real workload is eth_getLogs?"
+    a: "Because eth_getBlockByNumber measures the head-of-chain read path that every provider must implement, it is the fair cross-vendor probe. Providers that misbehave on head reads reliably misbehave on eth_getLogs at higher magnitude. Providers that keep head reads tight and consistent tend to keep eth_getLogs tight and consistent too. The latency leaderboard is a lower bound on indexer-workload latency, and a provider that fails the lower bound is not worth benchmarking on the harder workload."
+  - q: "Which provider supports full archive access without a paid plan?"
+    a: "The archive-depth matrix shows exactly which providers return non-pruned responses at 5M blocks on which chain, without a paid plan. Most no-key public RPCs prune at Geth's default cap around 7200 blocks and stop there. Keyed free tiers vary: some grant archive access on their signup tier, some gate it behind paid plans. The matrix answers this per provider per chain rather than as a marketing claim."
+  - q: "Are there RPCs specifically designed for indexing?"
+    a: "Indexer-adjacent products like The Graph Node's chain-specific gateways, Chainstack Global Nodes, and Alchemy Supernode advertise indexer-tuned SLAs. On the free-and-keyed tier this bench measures, those products are represented by their base RPC endpoints. Paid enterprise indexer-specific plans are outside the scope of this leaderboard because their SLAs are not publicly probeable without contract."
+  - q: "How does dRPC compare on indexer workloads?"
+    a: "dRPC's decentralized mesh routes each request across underlying node providers with consensus checks. That model preserves latency on head reads (see the leaderboard) but adds one layer of orchestration for archive reads. For an indexer's head-of-chain workload dRPC competes on the same axis as any keyed provider; for deep archive scans the per-chain archive-depth matrix is the honest signal."
+  - q: "How often is the leaderboard refreshed?"
+    a: "Every 60 seconds for head latency, every 5 minutes for the archive-depth matrix. The bench page reads 24h rolling windows so intraday spikes smooth out; longer-term shifts in provider capability show up within hours."
+
+related:
+  - alchemy-vs-quicknode-vs-infura-latency
+  - drpc-vs-publicnode-vs-1rpc
+  - which-crypto-price-api-is-the-fastest
+
+seo_title: "Best RPC for indexers 2026 live rankings"
+seo_description: "{{best_name}} leads at {{best_p50}} p50 latency (24h avg) on the OpenChainBench keyed and no-key RPC leaderboards, ranked live from three regions with archive-depth matrix."
+status: live

answers/cheapest-bridge-usdc-to-base.yml

@@ -0,0 +1,41 @@
+slug: cheapest-bridge-usdc-to-base
+question: "Which bridge is cheapest to move USDC to Base?"
+short_answer: |
+  {{best_name}} currently offers the lowest effective fee for a USDC bridge to Base at {{best_p50}} bps all in (24h avg), measured live by OpenChainBench across Across, Stargate, LI.FI, Squid, Socket, Relay and Near Intents on a $300 USDC probe.
+
+benchmark: bridge-fee
+
+intro: |
+  Bridge comparison articles publish rack rate fee schedules and stop there. The rack rate is one number in a bill that also includes destination gas, LP fees passed through as slippage, and the effective execution price the router actually delivers. On a $300 USDC bridge to Base, two providers quoting the same 5 bps headline can deliver very different real fees once the router walks the pool. This page answers the specific question retail and small-treasury movers actually search for: at $300 USDC notional, which bridge to Base is cheapest today. OpenChainBench queries the same USDC to Base intent against every major router every 5 minutes, computes the all-in effective fee including destination gas, and publishes the ranked leaderboard live.
+
+methodology: |
+  Every 5 minutes the harness sends the same intent (source: Ethereum mainnet USDC, destination: Base USDC, amount: $300 notional, receiver: probe wallet) to each router's quote API in parallel. Effective fee is computed as `(source_input_usd - destination_output_usd - destination_gas_usd) / source_input_usd` in basis points, so slippage, LP fees and gas are all inside the same number. Providers that fail to return a quote (5xx, rate limit, timeout) leave the previous gauge in place and increment a fetch_errors_total counter. The leaderboard ranks by 24h average of bridge_effective_fee_bps for the USDC to Base pair. The $300 size is the small ticket regime; sibling benches probe higher notional to expose where routers slip on size.
+
+limitations:
+  - "Quote fee only. This measures router-quoted effective fee, not settlement. Any router that quotes tighter than it settles would show a fast p50 with degraded real-world execution; the sibling bridge-quote-latency bench flags routers where quote-to-settle drift is measurable."
+  - "One size, one route. The $300 USDC to Base pair is the highest-search-volume small-ticket bridge query. At $50k notional the leaderboard re-orders because the spread and LP fee components dominate. Producers moving treasury size should read the per-size breakdown on the bench page."
+  - "Destination gas at quote time. Destination gas is included in the effective fee at the quoted receiver payout, not at a delayed execution instant. A destination gas spike between quote and settle would degrade the actual fee below what this leaderboard reports."
+  - "No canonical CCTP fast path. The USDC canonical bridge via Circle CCTP has different guarantees and speeds than the market-maker routers ranked here. The leaderboard measures the market-maker path (Across, LI.FI, Stargate, Squid, Socket, Relay, Near Intents) because it is the head-to-head every comparison article ranks."
+
+faq:
+  - q: "Which bridge is cheapest for a $300 USDC transfer to Base?"
+    a: "{{best_name}} leads the leaderboard at {{best_p50}} bps effective fee (24h avg) measured live on the same USDC to Base $300 probe. The full ranking including Across, Stargate, LI.FI, Squid, Socket, Relay and Near Intents re-sorts every 5 minutes against fresh Prometheus samples."
+  - q: "Why $300, and does the winner change at $10k or $100k?"
+    a: "$300 is the small-ticket regime that dominates retail search. At $10k the leaderboard shifts because LP-based routers (Stargate) start to lose ground to intent-based routers (Across, Near Intents) whose quotes are less size-dependent. At $100k the spread widens further and the choice becomes size-specific; the per-size tab on the bench page shows the leader at each notional."
+  - q: "Is Circle CCTP not on this ranking?"
+    a: "CCTP is Circle's canonical burn-and-mint path for USDC. It has different guarantees, speeds and a fixed protocol path, so it is not directly comparable to market-maker routers that price a swap through a pool. The bench measures the market-maker rankings because that is the choice retail actually makes; canonical CCTP is a separate decision users make once they know their maximum acceptable latency."
+  - q: "How is Across usually so cheap on this route?"
+    a: "Across runs an intent-based settlement model where relayers compete to fill from destination inventory. That model compresses the spread component to near zero on high-liquidity pairs like USDC Ethereum to Base. On less-liquid destinations Across loses its edge; that per-destination effect is why the leaderboard re-ranks by pair rather than emitting a single global cheapest bridge."
+  - q: "Is Stargate outdated for Base?"
+    a: "Stargate remains competitive on high-throughput pairs where its LP depth matters more than intent competition. On USDC to Base the pair-specific LP depth in 2026 has been narrower than intent-based competitors, which is why the leaderboard usually shows an intent router on top. Stargate wins on pairs where LP depth is the constraint."
+  - q: "How often is the leaderboard refreshed?"
+    a: "Every 5 minutes. The harness probes every router's quote API at that cadence, publishes bridge_effective_fee_bps to Prometheus, and the page reads a 24h rolling average. Because the recording rules re-aggregate every 30 seconds the on-screen ranking re-orders within a minute of any router changing quote behavior."
+
+related:
+  - which-bridge-has-the-fastest-quote-api
+  - which-bridge-has-the-cheapest-usdc-fee
+  - which-blockchain-has-cheapest-transaction-fees
+
+seo_title: "Cheapest bridge for USDC to Base 2026 live"
+seo_description: "{{best_name}} leads at {{best_p50}} bps effective fee on a $300 USDC to Base probe. Across, Stargate, LI.FI, Squid, Socket, Relay and Near Intents ranked live by OpenChainBench."
+status: live