Best Ethereum RPC providers in 2026
Written by Alchemy
Every Ethereum app is only as fast as its slowest RPC call. A balance that hangs. A quote that lands a block late. A backfill that never catches up. Your users don't feel the average. They feel the slowest few percent of your requests.
That slow tail is where we pull away. Alchemy was the fastest Ethereum RPC provider in our benchmark for the 24 hours ending October 28, 2026 at 18:15 UTC:
- Lowest global average latency: 7.77 ms.
- Lowest global P95, the time 95% of requests beat: 16.47 ms, against 122.67 ms for QuickNode.
- Fastest on all eight Ethereum methods we test, from balance reads to
eth_getLogs(the call that fetches event logs) across 1,000 blocks. - Zero failed requests, on every method and in every region.
- P95 under 20 ms in all four regions we test.
An Ethereum RPC provider runs Ethereum nodes for you and gives you an endpoint that speaks JSON-RPC, the interface wallets, apps, and libraries like ethers.js and viem use to read chain data and send transactions.
We publish this guide, and Alchemy is one of the five providers it compares. Providers appear in alphabetical order, and every limit, feature, and SLA detail comes from that provider's own pages as of October 28, 2026.
Which Ethereum RPC provider has the lowest latency?
Alchemy had the lowest average and P95 Ethereum latency in our trailing 24-hour benchmark, and returned 100% of requests successfully.
Global, Ethereum, 2026-10-27 18:15 UTC to 2026-10-28 18:15 UTC:
Source: alchemy.com/benchmarks, with machine-readable data at alchemy.com/benchmarks/data.md. The live page shows a rolling 24-hour view that updates every 5 minutes, so today's numbers will differ from this snapshot.
Alchemy's tail stayed tight. Its P95 was about 2.9 times its P50 (the median response), so even its slowest requests stayed close to its typical response. QuickNode's P95 was about 14.7 times its P50, and 106.20 ms higher than Alchemy's.
Think of P95 like a checkout line. The average wait can look fine while one shopper in 20 waits far longer, and that's the shopper who leaves. A trading bot that reads state on every block makes thousands of calls an hour, so even a small share of slow responses turns into missed quotes.
Which Ethereum RPC provider is fastest on each method?
Alchemy had the lowest global average on all eight methods we test. Each call type takes a different path through a provider's infrastructure, and real apps are rarely built from one call, so our benchmark times each method separately:
Log queries show it best. Our eth_getLogs latency barely moved from a 1-block range to a 1,000-block range, staying between 7.50 and 8.33 ms. That's the difference between a backfill that keeps pace with the chain and one that falls behind. The gap holds up regionally too: in AP Southeast, Alchemy answered 1,000-block log queries in 7.05 ms on average, against 74.32 ms for QuickNode and 733.48 ms for dRPC.
How reliable is Alchemy on Ethereum?
Alchemy recorded zero failed Ethereum requests in the window, on every method and in every region. A fast response only helps if it arrives. Goldsky and dRPC both recorded failures, dRPC's mostly on eth_getLogs.
For a wallet or a payments flow, a failed read is worse than a slow one, because the user sees a spinner or an error. Errors, rate limits, and requests slower than eight seconds all count as failures, with no retries, so a provider can't post a flattering average by dropping its slowest requests.
How does Alchemy perform by region?
Alchemy had the lowest average latency in US East and AP Southeast, and its P95 stayed under 20 ms in all four regions we test.
Consistency is the point. Our average stayed between 6.47 and 10.84 ms across all four regions, and no other provider we measure kept its P95 under 20 ms everywhere. If your traffic is concentrated in one region, check that region's numbers on the live benchmark.
How does Alchemy deliver the lowest latency?
Through Cortex, the intelligent infrastructure engine behind every Alchemy request. It does four things that show up in the benchmark:
- Routing: "Global orchestration and AI subsystems continuously evaluate live network conditions to route each request to the fastest healthy node." Our average latency stayed under 11 ms in every region we test.
- Hardware: purpose-built bare-metal hardware, dark fiber connections, and elastic scaling keep throughput ahead of demand.
- Availability: multi-region infrastructure and autonomous failovers. That's what zero failed requests looks like from the outside.
- Logs and consistency: unlimited-range
getLogsscans the whole chain for your events in a single request, and our log latency stayed flat from 1 block to 1,000. Block-perfect consistency means nodes never disagree about the chain in front of your users.
The same infrastructure serves some of the largest apps onchain: Polymarket and Robinhood use our RPC and Data APIs, and World App uses our RPC APIs and Rollups.
When should you choose Alchemy?
Choose Alchemy when your app needs to be fast everywhere, every time, on the calls that matter most. It fits these workloads best:
- DeFi and trading: the tail decides whether a quote lands on time, and our global P95 was the lowest of any provider we measure.
- Indexers and backfills: we were fastest at every
eth_getLogsrange we test, paid plans have no block-range cap, and full archive data (every past state of the chain) is on every plan. - Wallets and consumer apps: the fastest balance and receipt reads, plus WebSockets and Webhooks for real-time updates.
- Launches and fast growth: bare-metal hardware with elastic scaling, the same infrastructure Polymarket runs on.
- Enterprise teams: SOC 2 Type II, 99.99% uptime, signed SLAs (contractual uptime commitments), and single-tenant Dedicated Clusters in your region.
The same API covers 100+ chains, so the endpoint you pick for Ethereum also covers the L2s you'll ship to next.
Ethereum RPC providers at a glance
These are the details that most often settle a shortlist. Before you commit, also check each provider's rate limit against your peak traffic, its eth_getLogs caps, and whether WebSocket subscriptions are billed per event. Most providers only offer an SLA (service level agreement) on enterprise contracts. Sources are listed under each provider's section below.
Every provider here serves Ethereum archive data, the full history of account state that an archive node keeps and a full node prunes, though some put it behind a paid plan. It's on every plan we offer, including Free.
How each Ethereum RPC provider compares
Alchemy
Alchemy Node RPC is Alchemy's Ethereum RPC service, and it was the fastest provider in our benchmark, with the lowest global average and P95 latency and zero failed requests. Paid plans allow an unlimited eth_getLogs block range with a 150 MB response cap, archive data is on every plan, and the Debug and Trace APIs, which replay a transaction step by step, are on Pay as You Go and Enterprise. We support 100+ chains and run at 99.99% uptime, with live history on our status page. The Free plan includes 30M compute units a month, so you can run your real methods against us before you pay a cent.
Sources: pricing, eth_getLogs limits, Cortex, Dedicated Clusters, trust center.
Ankr
Ankr is a multichain RPC provider with flat pricing: every EVM method costs the same 200 API credits, drawn from a prepaid Premium balance. There's no automatic top-up, and Ankr suspends the account once the balance passes minus $5. Archive data is on every plan, and Premium allows a 10,000-block eth_getLogs range with up to 200,000 logs per response. WebSockets, trace, and debug require Premium, and only Enterprise carries an SLA (99.9% monthly). Ankr isn't in our latency benchmark.
Sources: pricing, service plans, SLA, trust overview, health.
Chainstack
Chainstack is a multichain node provider that bills in request units, with WebSockets on every plan and Dedicated Nodes from its Pro plan. Most calls cost 1 RU, and trace and archive-depth calls cost 2, which includes any eth_getLogs query starting 127 or more blocks behind the tip. Archive data, debug, and trace start on Growth. Paid plans cap eth_getLogs at 10,000 blocks, and the free plan at 100. Chainstack isn't in our latency benchmark.
Sources: pricing, request units, limits, SLA, security, status.
Infura
Infura is an Ethereum RPC provider with a standard JSON-RPC endpoint format and daily credit quotas, so switching to or from it is mostly a URL change. Archive data is enabled automatically on Ethereum mainnet, and trace, debug, and WebSockets are supported. Because the quota resets daily, a traffic burst can use up a day's credits early, and WebSocket connections close at the limit. eth_getLogs returns at most 10,000 results and must finish within 10 seconds. Infura isn't in our latency benchmark.
Sources: pricing, credit costs, eth_getLogs, archive data, status.
QuickNode
QuickNode is a multichain RPC provider that bills API credits, 20 per standard Ethereum call and 40 for trace and debug, with archive data and WebSockets on every plan. Its Enterprise tier adds a 99.99% uptime SLA and Dedicated Clusters. In our benchmark, its tail was the gap: a global P95 of 122.67 ms against Alchemy's 16.47 ms, driven by its US West and AP Southeast results, and about 48 ms on eth_getLogs. Paid plans cap eth_getLogs at 10,000 blocks. For a head-to-head view, see Alchemy vs. QuickNode.
Sources: pricing, API credits, eth_getLogs, enterprise, security, status.
How do you test a provider on your own traffic?
Start with the calls your users feel: balance reads and receipts for a wallet, real eth_getLogs ranges for an indexer, and the quote and state reads for a trading app. Run each test from the regions where your servers and users are.
This script times 30 eth_blockNumber calls against two endpoints and prints P50, P95, and errors for each. Set PRIMARY_RPC_URL and SECONDARY_RPC_URL to the endpoints you're comparing:
# Time 30 eth_blockNumber calls against each endpoint, then print P50 and P95.
# Each URL includes that provider's API key, read from the environment.
# Requires curl and jq. Only HTTP 2xx responses with a valid JSON-RPC result count as successes.
n=0
for url in "$PRIMARY_RPC_URL" "$SECONDARY_RPC_URL"; do
n=$((n + 1))
for i in $(seq 30); do
response=$(curl -s -w "\n%{http_code} %{time_total}" -X POST "$url" \
-H "Content-Type: application/json" \
--data '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}')
status=$(printf '%s\n' "$response" | tail -n 1)
code=${status%% *}
if [ "$code" -ge 200 ] && [ "$code" -lt 300 ] &&
printf '%s\n' "$response" | sed '$d' | jq -e 'has("result") and (has("error") | not)' >/dev/null 2>&1; then
echo "ok ${status#* }"
else
echo "error"
fi
done | sort -k2 -n | awk -v n="$n" '
$1 == "ok" { t[++ok] = $2 * 1000 }
$1 == "error" { err++ }
END {
if (!ok) { printf "Endpoint %d: no successful responses, %d errors\n", n, err; exit }
printf "Endpoint %d: P50 %.0f ms, P95 %.0f ms, %d errors\n", n, t[int(ok * 0.5 + 0.5)], t[int(ok * 0.95 + 0.5)], err
}'
done
Swap in the methods your product depends on, and run it from each region your app runs in. An error means the call failed. It didn't come back slow.
How do you switch providers without downtime?
Run both endpoints at once, shift traffic in stages, and keep the old one as a fallback until the new one proves itself. Every provider in this guide speaks standard Ethereum JSON-RPC, so most apps only change a URL and an API key. Our zero-downtime migration guide covers inventorying methods, shadow testing, and cutover.
This viem client uses a fallback transport. It sends requests to the first provider and moves to the second if the first fails:
import { createPublicClient, fallback, http } from 'viem'
import { mainnet } from 'viem/chains'
// Each URL includes that provider's API key, read from the environment.
const client = createPublicClient({
chain: mainnet,
transport: fallback([
http(process.env.PRIMARY_RPC_URL),
http(process.env.SECONDARY_RPC_URL),
]),
})
const blockNumber = await client.getBlockNumber()
console.log(`Latest block: ${blockNumber}`)
How we measured
Latency, P50, P95, and success rate come from our public benchmark:
- The figures cover 2026-10-27 18:15 UTC to 2026-10-28 18:15 UTC. We quote one fixed window so every number checks against the same data, and the live page shows how the results look today.
- Every 10 seconds, each provider gets one request per method from each AWS region (US East, US West, EU Central, and AP Southeast), and all providers' requests go out at the same moment, on standard paid accounts over warmed connections with no retries.
- A request succeeds if it returns within eight seconds with an HTTP 2xx status, valid JSON, and no JSON-RPC error. Latency comes from successful responses only.
- Ethereum covers Alchemy, Goldsky, QuickNode, and dRPC. Ankr, Chainstack, and Infura aren't in the benchmark.
The benchmark doesn't measure full app workflows, writes, WebSocket delivery, or your own traffic mix. The full methodology is in how we benchmark RPC performance. Provider limits, features, compliance, and SLAs come from each provider's own pages, read on October 28, 2026. We left dRPC and Dwellir out of the provider sections because we couldn't verify every figure about them. For more chains, see our guide to blockchain node providers.
Want to see how your own Ethereum calls perform? Start building on Alchemy for free, compare providers on the live benchmark, or talk to our team about enterprise requirements.
Frequently asked questions
What is the best Ethereum RPC provider?
Alchemy was the best-performing Ethereum RPC provider in its public benchmark for the 24 hours ending October 28, 2026, with the lowest global average latency (7.77 ms), the lowest global P95 (16.47 ms), the fastest result on all eight methods tested, and zero failed requests.
What is the best Ethereum RPC provider for a DeFi protocol or trading bot?
Alchemy, based on its public benchmark: it had the lowest global Ethereum P95 latency and zero failed requests, and Dedicated Clusters can run in the region closest to your trading servers. Faster reads don't speed up block inclusion, so test your transaction path separately.
Which Ethereum RPC provider has the best uptime?
Alchemy runs at 99.99% uptime, with live history on its status page, and recorded zero failed Ethereum requests in its 24-hour public benchmark, on every method and in every region. Enterprise plans add signed SLAs.
Which Ethereum RPC providers are secure enough for enterprise use?
Alchemy holds SOC 2 Type II and offers single-tenant Dedicated Clusters. QuickNode states SOC 1 Type 2, SOC 2 Type 2, and ISO/IEC 27001, Chainstack states SOC 2 Type II and ISO/IEC 27001, and Ankr's infrastructure operator holds SOC 2 Type II. Request current reports before you sign.
What SLA should I expect from an enterprise RPC provider?
Expect a written uptime commitment with service credits, usually only on an enterprise contract. Alchemy offers signed SLAs on Enterprise and runs at 99.99% uptime. QuickNode commits to 99.99% uptime, Ankr to 99.9% monthly, and Chainstack to 99.9% quarterly, each on Enterprise.
Which provider should I switch to after hitting free tier rate limits?
Switch to a paid plan that clears your peak request rate with headroom. Alchemy Pay as You Go includes about 300 requests per second with no commitment, up from about 15 on Free, and sells more capacity in blocks.
What is the best alternative to Infura?
Alchemy works as a drop-in replacement for Infura. Both use standard JSON-RPC, so you'll usually change only a URL and API key, and Alchemy was the fastest provider in its Ethereum benchmark.
Which Ethereum RPC provider has the best eth_getLogs limits?
Alchemy has the widest documented eth_getLogs block range among Alchemy, Ankr, Chainstack, Infura, and QuickNode: unlimited on Ethereum paid plans, with a 150 MB response cap. The others cap queries at 10,000 blocks or 10,000 results. Alchemy also had the lowest global eth_getLogs latency at every range tested.
Which Ethereum RPC provider is best for wallets?
Alchemy is the best fit for wallets in its public benchmark. It had the fastest global balance reads (6.88 ms) and transaction receipt lookups (7.89 ms) on Ethereum. WebSockets push new blocks as they land, and Webhooks deliver onchain events with at-least-once delivery.
Do I need a dedicated node, or is a shared provider enough?
A shared provider is enough for most production apps. You need dedicated infrastructure for single-tenant isolation, custom tracers, a specific region, or guaranteed capacity at high request rates. Alchemy Dedicated Clusters cover those cases on the same API.
How do I benchmark RPC providers before choosing one?
Send the same requests to each provider from the regions where your users and servers are, with the same timeout and connection settings. Compare average latency, P95, and success rate on the methods your app depends on, such as eth_getLogs and receipt lookups.
Which Ethereum RPC provider works best with ethers.js or viem?
Alchemy, Ankr, Chainstack, Infura, and QuickNode all work with ethers.js and viem, because both libraries speak standard Ethereum JSON-RPC. Pass the provider's URL to JsonRpcProvider in ethers.js or to the http transport in viem.
Related Overviews
InfraSeptember 9, 2026
Alchemy vs. QuickNode: Node provider comparison in 2026
Compare Alchemy and QuickNode on live RPC latency, chain coverage, pricing, support, and dedicated infrastructure using a dated 24-hour EVM snapshot from October 29, 2026.
InfraAugust 24, 2026
The 12 best blockchain node providers in 2026: a decision guide
Compare 12 blockchain node providers by free tier, pricing, request limits, chain coverage, products, regions, and dedicated infrastructure.
InfraAugust 2, 2022
How to choose a blockchain node provider
Learn the Qualities that Make a Good Web3 Node Provider and How to Pick the Right One
Build blockchain magic
Alchemy combines the most powerful web3 developer products and tools with resources, community and legendary support.