Skip to content
0%

Global RPC edge network: how to evaluate multi-region node providers

Alchemy team headshot

Written by Alchemy

Published on November 19, 202612 min read

RPC edge networks measured by region

Every RPC call your app makes has to reach a node and come back before your user sees a price, a balance or a confirmation. An edge network decides where that trip starts. A good one sends each request to the closest healthy region and, when a region fails, moves traffic to the next one without you changing an endpoint.

We run our own edge on bare metal, covering US East, US West, EU Central and Southeast Asia, and Cortex routes every request to the healthiest node that can answer it. On our live benchmark on November 19, 2026, Alchemy had the lowest p95 latency of the four providers tested on Ethereum, Optimism and Arbitrum in every test region, with a 100% success rate. Distance sets the floor. Routing decides the tail.

What makes an RPC edge network good?

An edge network is the layer that receives your request before any blockchain node sees it. Think of it like a hotel front desk: being near the door gets you served faster, but the desk also has to know which rooms are ready and send you to one of those.

Four things decide whether a provider's edge helps you:

  • Proximity. Your request should enter the network in the region closest to where it starts. Distance adds round-trip time that fast hardware can't win back.
  • Routing. Once a request lands, something has to pick the node that answers it. A nearby region with a slow or lagging node still gives you a slow or stale answer.
  • Failover. Regions degrade. A good edge notices on its own and moves traffic to another region, with no endpoint change and no retry logic in your code.
  • Consistency. When traffic moves between nodes or regions, the data has to stay current. Failing over to a node a few blocks behind turns an outage into a wrong answer.

Each of these shows up in your product. A slow read on a trading desk is a stale quote. A failed read in a wallet is a balance that won't load. A stale read after failover is a liquidation that fires late.

Where does Alchemy's edge network run?

Our edge covers four regions, and every request enters at the closest healthy one automatically. You use the same endpoint everywhere, with nothing to set up per region.

Region
Covers

US East

North America

US West

North America

EU Central

Europe

Southeast Asia

Asia-Pacific

The edge doesn't care which chain you call. A request for Ethereum and a request for Solana from the same city enter the same regional edge, which then routes each to the right network. If a region doesn't serve your network yet, the request goes to the closest region that does, so nothing breaks while coverage grows.

We keep investing in regional performance. In September 2026 we improved our Tokyo infrastructure, cutting median latency for requests from Japan by up to 8x.

How does a request move through Alchemy's edge network?

Every request takes the same path, and each step has one job.

  1. Your app sends a request to its Alchemy endpoint.
  2. DNS sends it to the nearest healthy region. The connection and TLS handshake are set up there, close to you, which is where most of the round-trip saving comes from.
  3. The edge proxy checks it. Our Alchemy Edge Proxy runs on bare metal we operate, with no third-party CDN in the serving path. It validates the request, applies rate limits and security rules, and works out which backend can serve it.
  4. Cortex picks the serving stack. It checks which stacks support the network you called and which are healthy, then sends the request to the closest one.
  5. The gateway picks the node. It narrows the candidates by live health checks, agreement on the current state of the chain, recent measured latency and the method you called. A heavy historical query and a balance read don't land on the same machine.
  6. The response comes straight back to your app.

Steps 4 and 5 are where providers differ most. Sending traffic to a nearby region is now standard. Picking the node inside that region on every request, from live data, is what the Cortex router does. We don't switch "lowest latency" on as a setting. We recompute it for every call.

Owning this path also moved the numbers. When we replaced a third-party CDN with our own edge in October 2025, p99 latency in Asia-Pacific fell from 150 ms to 20 ms, and p95 across all networks roughly halved, from about 200 ms to about 100 ms.

What happens when a region fails?

You keep using the same endpoint, and traffic moves to another region on its own. Here is what makes that work:

  • Health checks run continuously at the edge for every region. When a region is marked unhealthy, DNS stops sending traffic to it.
  • Each region has an ordered fallback list. Traffic goes to the next-closest region on that list, so the path is set before anything fails.
  • Failover is layered. Cortex reroutes around a failed node inside a region, and a degraded region hands its traffic to a secondary region, with a further fallback behind that.
  • Data stays current through the move. Real-time global replication keeps every region consistent, so landing on a farther region doesn't mean reading older data.
  • Routing changes need no redeploy. We can drain a region or reroute a network from configuration, without restarting the proxy.

Cortex also steers around nodes that are congested, lagging or running a client version with a known bug, before they go down. Because failover is part of every routing decision, a weak node gets skipped before your users notice it.

Polymarket is the stress case. Through the 2024 US elections they ran over 125,000 concurrent users and $3.3 billion in bets on Alchemy, with requests rerouted on p99 latency to hold performance up.

How should you compare RPC edge networks?

Measure from where your traffic starts, on the methods your app calls, and read the slow end of the results as closely as the typical one.

Measure
Why it matters
How to test it

Latency by region

Your users feel the latency in their own region, and a global average hides it

Run the same test from each region your app or users are in

p50 and p95

p50 is the typical request. p95 is the slowest 5%, where stale prices and slippage come from

Collect several thousand requests per provider per chain

Success and timeout rate

A fast answer only counts if it arrives

Count timeouts, rate limits and errors as failures, outside the latency numbers

Failover behavior

Tells you whether a regional incident becomes your incident

Ask how regions fail over and whether you have to configure anything

Consistency across regions

A failover that returns stale state is worse than a slow answer

Compare block height and state reads across regions during a test

Method and chain coverage

A provider can lead on one method and trail on another

Benchmark each chain and method separately

Debuggability

You need to see why a request was slow or failed

Check request logs, error detail and status history

Two rules keep the comparison fair. Send the identical payload to every provider from the same machine, with the same warm-up, reused connections and timeout. And give each request one attempt with no retries, because a retry turns a failure into a slow success and hides it. Latency should come from successful responses only, with failures counted on their own. That is how our public benchmark works.

What does our benchmark show by region?

On our live benchmark's combined Ethereum, Optimism and Arbitrum view, Alchemy had the lowest p95 latency of the providers tested in every test region, at a 100% success rate in each.

This snapshot is from alchemy.com/benchmarks, taken November 19, 2026 at 22:35 UTC over the trailing 24 hours. It uses the benchmark's EVM Overall view, which combines Ethereum, Optimism and Arbitrum and leaves out the 1,000-block eth_getLogs test.

Region
Alchemy
dRPC
Goldsky
QuickNode

US East

19.56 ms

154.76 ms

56.63 ms

28.91 ms

US West

41.37 ms

636.74 ms

56.34 ms

210.18 ms

EU Central

20.93 ms

86.85 ms

56.72 ms

33.33 ms

AP Southeast

36.25 ms

617.74 ms

56.34 ms

234.87 ms

p95 latency, successful responses only.

Averages sit closer together, and in EU Central and AP Southeast another provider posted a lower average in this window. Across those three chains and all four regions combined, Alchemy averaged 13.31 ms at 100% success. Base, BNB Chain and other chains have their own views on the live benchmark, so check the chain you run on.

How the benchmark runs:

  • Every provider gets the same JSON-RPC read payload, on a standard paid account, from the same AWS runner region: US East, US West, EU Central or AP Southeast.
  • Tests run about every 10 seconds, and the page refreshes every 5 minutes from a trailing 24-hour window.
  • Methods include eth_getBalance, eth_getBlockByNumber at the earliest and latest blocks, eth_getLogs over several block ranges, and eth_getTransactionReceipt.
  • Latency counts successful responses over warmed, reused connections. HTTP errors, JSON-RPC errors, rate limits and anything past the 8-second timeout count as failures. There are no retries.

The full dataset, by chain, region and method, is public as text at alchemy.com/benchmarks/data.md.

How does multi-region routing work on EVM chains?

Every EVM chain takes the same path: nearest edge region, then Cortex picks a healthy node that's current with the chain. What changes by chain is how much a slow or stale node costs you.

  • Ethereum. The heaviest historical queries. eth_getLogs over wide block ranges is where landing on the right node type matters most.
  • Base. Base ships 200 ms block updates through Flashblocks, so an RPC path slower than that becomes the bottleneck, and a node slightly behind returns state that has already changed.
  • Polygon. Heavy state reads from trading and payments apps. In our Tokyo test, Polygon showed the widest tail-latency gap between providers.
  • Arbitrum. High-volume DeFi traffic, where a slow eth_call means a stale price for a swap or a liquidation check.
  • BNB Chain. Heavy retail trading across Asia, where every millisecond between a price update and an order counts.

The live benchmark reports results per chain, including Ethereum, Arbitrum, Base and BNB Chain, so you can check the chain you run on.

How does multi-region routing work on Solana?

Solana runs on the same multi-region edge and failover, with infrastructure built for Solana's data load. Most Solana traffic is reads (balances, account state, program data and history), so that's where we focused.

  • Reliable reads. Solana requests route to the nearest healthy region like any other chain, with 3 to 5 layers of failover behind them and 99.99% uptime.
  • Archival access. Historical calls like getTransaction, getBlock and getSignaturesForAddress run on a storage layer built for Solana's access patterns, and our archive calls are up to 20x faster.
  • Real-time data. Streaming runs on the same multi-region infrastructure, with block replay when a connection drops, so a reconnect doesn't leave gaps.
  • Measured by region. Our live Solana benchmark tests five providers from the same four regions, under the same rules as EVM.

For a full comparison of Solana providers, see our Solana RPC overview.

How do you move an endpoint to Alchemy?

Most teams switch in minutes, because Alchemy speaks standard JSON-RPC. There's no new SDK and no per-region setup.

  1. Create a free account and copy your endpoint URL for each network you use.
  2. Swap your current RPC URL for your Alchemy endpoint. The same endpoint works from every region.
  3. Send a slice of traffic first, and compare latency and success rate against your current provider from your own regions.
  4. Move the rest once the numbers hold. Keep your old provider as a fallback during the switch for a zero-downtime cutover.

The full playbook is in how to migrate between RPC providers with zero downtime. If you need single-tenant nodes in a specific region, Alchemy Dedicated Clusters run the same routing on hardware reserved for you, with opt-in failover to the shared fleet.

Want to see how our edge performs from your regions? Start building on Alchemy for free, with no contract and no waitlist, check the live benchmark, or talk to our team about multi-region workloads.

Frequently asked questions

Which RPC provider has the best global edge network?

Judge edge networks by tail latency from your own regions and by automatic failover between them. On Alchemy's live benchmark on November 19, 2026, Alchemy had the lowest p95 latency of the four providers tested on Ethereum, Optimism and Arbitrum in all four test regions, at a 100% success rate. Alchemy runs its own bare-metal edge with no third-party CDN in the serving path, and Cortex routes each request to the healthiest node.

How many edge regions does Alchemy run?

Alchemy's edge covers four regions: US East, US West, EU Central and Southeast Asia. Every request enters at the closest healthy region automatically through the same endpoint, with no per-region setup. If a region doesn't serve a network yet, requests for that network go to the closest region that does. Alchemy keeps investing in regional performance, including Tokyo, where median latency from Japan fell by up to 8x.

How does multi-region failover work for RPC?

On Alchemy, health checks run continuously at the edge for every region. When a region is marked unhealthy, DNS stops sending traffic to it and routes requests to the next-closest region on a predefined fallback list. Real-time global replication keeps regions consistent, so failover doesn't return older data. Your app keeps the same endpoint and configures nothing.

Does Alchemy route requests to the nearest region?

Yes. DNS sends each request to the nearest healthy Alchemy region, where the connection and TLS handshake are set up close to you. Cortex then picks the closest healthy serving stack for the network you called, and a gateway picks the node based on health, chain state, recent latency and the method requested. This happens automatically on every request.

How do I measure RPC latency by region?

Send the same JSON-RPC requests to each provider from a machine in each region your app runs in. Use paid accounts, warmed and reused connections, one fixed timeout and no retries. Collect several thousand requests per provider per chain, then compare p50, p95 and success rate together. Count timeouts and errors as failures, and keep them out of the latency numbers.

Is edge latency different for Ethereum, Base and Solana?

Yes, because each chain moves at a different speed and carries different traffic. Base ships block updates every 200 ms through Flashblocks, so a slow or lagging node shows up fast. Ethereum carries heavier historical queries. Solana traffic is mostly reads and archival lookups. On Alchemy all three use the same multi-region edge, and the live benchmark reports each chain separately.

What is Cortex?

Cortex is the engine behind the Alchemy platform, from the node fleet up through routing to the RPC and Data APIs. For every request it decides which region accepts it, which healthy node serves it, and what happens if that node degrades. It also keeps requests on the same view of the chain, so reads stay consistent whichever node serves them.

How do I test Alchemy against my current provider?

Create a free Alchemy account and endpoint, then send the same requests to Alchemy and your current provider from the same machine in each of your regions. Test the methods your users feel, such as eth_call and eth_getLogs, and compare p95 and success rate side by side. Alchemy's live benchmark at alchemy.com/benchmarks gives you a public baseline to check against.

Do dedicated nodes run in multiple regions?

Yes. Alchemy Dedicated Clusters run multiple redundant nodes per chain per region, on single-tenant infrastructure with the same routing as the shared fleet. Clusters support regional deployments, so you can place one where your traffic comes from. You can opt in to automatic failover to Alchemy's shared infrastructure if traffic outgrows the cluster.

Background gradient

Build blockchain magic

Alchemy combines the most powerful web3 developer products and tools with resources, community and legendary support.