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

Arc: 6 free public RPC endpoints answering `eth_getBlockByNumber` every 60 seconds from us-east, eu-west and Singapore, ranked by 24h median. dRPC leads at 40 ms; the Circle-operated endpoint measures 52 ms. The same page carries the private cohort (API key), Alchemy, Chainstack, GetBlock, Quicknode and Dwellir on their keyed Arc endpoints every 120 seconds from us-east and eu-west: switch the Access selector; Chainstack leads it at 6 ms. We measure the round-trip latency of a single, identical RPC call (`eth_getBlockByNumber`) against every no-key public Arc endpoint that sustains continuous probing, 6 providers, every 60 seconds, from us-east, eu-west and Singapore, and against the keyed endpoints of Alchemy, Chainstack, GetBlock, Quicknode and Dwellir every 120 seconds from the same three regions, the keyed headline averaging us-east and eu-west because GetBlock has no Arc endpoint in Singapore. The harness classifies every response (ok / http_err / jsonrpc_err / stale / timeout) so the leaderboard rewards sustained, honest availability rather than a fast error message. Arc produces blocks in well under a second; the stale check tolerates 40 blocks (20 s) on the public cohort and 20 on the keyed one.

• ·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](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: a Free plan key (30M CU per month, 300 compute units per second), the tier any reader gets; 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.