8 Best Ethereum RPC Providers in 2026, Including Archive Nodes

Last updated: 25 October 2026 · Prices, archive rules, method costs and eth_getLogs limits rechecked on vendor pages on 25 October 2026

The best Ethereum RPC providers in 2026 are Chainstack for overall value with audits, Alchemy for the biggest free archive allowance, and dRPC for the cheapest flat meter on archive calls. We ranked eight providers on six weighted criteria, priced three archive-heavy workloads on every meter, and tested public endpoints against blocks from 2015.

Archive access is where Ethereum RPC plans differ most. Some vendors include it on the free tier, some charge double for it, and some cap how many blocks one eth_getLogs call can scan. This guide expands the Ethereum side of our ranking of the 12 best RPC node providers, uses the same weights, and our methodology page explains how we collect prices and screenshots. If you are leaving a current vendor, our Infura alternatives and Alchemy alternatives guides apply the same scorecard, and our Base RPC providers ranking covers the leading L2.

The Decision Kernel

Pick an Ethereum RPC provider by how much of your traffic reads old state. A wallet that shows balances at past blocks, an indexer that replays logs from genesis and a forensics tool that traces old transactions all hit archive nodes. Tag each request as head or archive for one week before you compare a single plan. The shortcuts below cover the common cases.

• Lowest bill with audits: Chainstack Growth at $49, which charges 2 request units per archive call and states SOC 2 Type II and ISO 27001.
• Largest free archive allowance: Alchemy, with 30M compute units a month and archive data on Free, or about 1.5M archive balance reads.
• Cheapest archive and trace meter: dRPC, which bills every method at the same flat rate, including debug_* and trace_*.
• Lowest latency and the widest audit set: QuickNode, with archive on every plan and SOC 1, SOC 2 and ISO 27001 reports.
• Dedicated Ethereum archive node: GetBlock from $1,500 a month, or Chainstack and QuickNode dedicated nodes on request.
• Bursty traffic on prepaid credits: Ankr pay as you go at 1,500 requests per second.

How We Ranked the Ethereum RPC Providers

We scored each provider from 1 to 5 on six criteria, weighted them and doubled the total, using the same weights as our 12-provider RPC ranking. For this Ethereum list, the free tier score depends on archive access, and the features score counts archive, debug, trace and log range limits. Every price, limit and audit claim here links to a vendor page we checked on 25 October 2026. Our methodology covers the rest.

• Price per call, 25%: the monthly bill for archive-heavy Ethereum method mixes, converted from each billing unit.
• Reliability, 20%: public latency benchmarks, uptime claims and support response targets.
• Compliance, 15%: SOC 2, ISO 27001 and other audits stated on the vendor’s own pages.
• Features, 15%: archive data, debug and trace APIs, eth_getLogs range limits, WebSockets and dedicated nodes.
• Coverage, 15%: Ethereum L2s and other chains on one account.
• Free tier, 10%: how much Ethereum archive traffic a team can run before paying.

Provider	Price (25%)	Reliability (20%)	Compliance (15%)	Features (15%)	Coverage (15%)	Free tier (10%)	Score
Chainstack	5	4	5	4	4	2	8.4
Alchemy	3	4	4	5	5	5	8.3
dRPC	5	4	2	4	5	4	8.2
QuickNode	3	5	5	5	4	2	8.1
GetBlock	3	5	4	4	5	1	7.6
Ankr	2	3	4	3	4	4	6.3
Infura	4	3	1	3	3	4	6.1
Tatum	1	3	5	4	5	1	6.1

Why Archive Access Changes the Bill

A full Ethereum node keeps recent state, roughly the last 128 blocks, and can rebuild older state only slowly. An archive node keeps the state at every block since genesis, which is why it answers a balance query at block 1,000,000 in one call. QuickNode’s full vs archive guide puts an archive node at about 12 TB on Geth and about 2 TB on Erigon, and growing. Most providers draw the archive line at about 128 blocks behind the tip, and two of them charge double past it.

• Charged double: Chainstack bills 2 request units for calls 127 or more blocks behind the tip, and judges eth_getLogs by its fromBlock, per its request unit rules. GetBlock applies an archive modifier of 2 to calls served by an archive endpoint, per its CU formula.
• Same price: Alchemy, QuickNode, dRPC and Ankr bill archive calls at their normal rates. Infura’s credit cost page says archive requests older than 128 blocks currently cost the same as recent ones, and warns this might change.
• Method weights still apply: Infura charges 255 credits for eth_getLogs and 1,000 for debug_*, and Tatum charges 50 credits for debug and trace calls, which Tatum’s docs label as archive methods that may cost more.

Ethereum RPC Providers at a Glance

The table lines up each provider’s billing unit, how it treats archive calls, the entry paid plan and its throughput. Prices are monthly list prices from each pricing page on 25 October 2026, before annual discounts.

Provider	Billing unit	Archive call cost	Entry paid plan	Rate limit
Chainstack	Request units (RU)	2 RU, against 1 RU at the head	Growth $49: 20M RU	250 rps
Alchemy	Compute units (CU)	Same CU as head calls	Pay as you go: $0.525 per 1M CU	300 rps
dRPC	Compute units	Flat 20 CU, 16 inside the Pro pool	Pro $49: 163M CU, about 10M requests	300 rps
QuickNode	API credits	20 credits, 40 for trace and debug	Build $49: 80M credits	50 rps
GetBlock	Compute units	40 CU on an archive endpoint	Starter $49: 90M CU	250 rps
Ankr	API credits	$0.02 per 1,000 EVM requests	Pay as you go from $10	1,500 rps
Infura	Credits per day	Same credits as head calls, for now	Developer $50: 15M credits a day	4,000 credits per second
Tatum	Credits	2 standard, 5 for eth_call, 50 for traces	Starter $49: 4M credits	200 rps

What One Million Archive Calls Cost

Converting each unit to dollars shows how far apart the meters sit on old-block traffic. We used the entry paid plan fully used and Ethereum mainnet calls more than 128 blocks behind the tip. A million archive debug traces cost $4.81 on dRPC Pro, $111.11 on Infura Developer and $612.50 on Tatum Starter.

Plan	Archive getBalance	Archive eth_call	eth_getLogs	debug_traceTransaction	Above the allowance
Chainstack (Growth)	$4.90	$4.90	$4.90	$4.90	$15 per 1M RU
Alchemy (PAYG)	$10.50	$13.65	$31.50	$21.00	Same $0.525 per 1M CU
dRPC (Pro)	$4.81	$4.81	$4.81	$4.81	$6 per 1M requests
QuickNode (Build)	$12.25	$12.25	$12.25	$24.50	$0.62 per 1M credits
GetBlock (Starter)	$21.78	$21.78	$21.78	$43.56	Top up CUs or change plan
Ankr (PAYG)	$20.00	$20.00	$20.00	$20.00	Same rate, prepaid
Infura (Developer)	$8.89	$8.89	$28.33	$111.11	402 errors, or $200 for 55M credits
Tatum (Starter 4M)	$24.50	$61.25	$24.50	$612.50	Move up a plan

Overage changes the picture once you outgrow the entry plan. Chainstack’s extra request units cost $15 per million on Growth, which makes an archive call $30 per million past the allowance. QuickNode overage runs $0.62 down to $0.50 per million credits, and dRPC bills $6 per million requests past its pool.

What Three Archive Workloads Cost

We built three archive-heavy method mixes, converted each into every vendor’s unit and picked the cheapest public plan that covers the volume, archive access and a peak of three times the average rate. dRPC had the lowest bill in all three workloads, and Chainstack was second in each.

Provider	Wallet history, 20M	Indexer backfill, 60M	Trace forensics, 20M
Chainstack	$199 (Pro)	$499 (Business)	$199 (Pro)
Alchemy	$277 (Pay as you go)	$1,386 (Pay as you go)	$378 (Pay as you go)
dRPC	$108 (Pro)	$274 (Scale)	$108 (Pro)
QuickNode	$247 (Build)	$632 (Scale)	$355 (Accelerate)
GetBlock	$349 (Scale)	$979 (Premium)	$611 (Pro)
Ankr	$400 (Pay as you go)	$1,100 (Deal ($500))	$400 (Pay as you go)
Infura	$225 (Team, busy days over quota)	Enterprise quote	Enterprise quote
Tatum	$1,199 (Scale 150M)	$1,199 (Scale 150M)	Quote, above public plans

• Wallet history, 20M requests: 40% archive eth_getBalance, 20% archive eth_call, 20% head eth_call, 10% head block reads and 10% archive eth_getLogs.
• Indexer backfill, 60M requests: 60% archive eth_getLogs, 25% archive eth_getBlockByNumber and 15% archive eth_getBlockReceipts.
• Trace forensics, 20M requests: 40% debug_traceTransaction, 20% trace_block, 20% eth_getLogs and 20% block reads, all on old blocks.

Infura’s numbers come from its daily quota. The wallet mix averages 97.5 credits per request, about 65M credits a day, and a day at 1.5 times the average needs about 97.5M, above the Team plan’s 75M. The indexer needs about 646M credits a day and the trace job about 351M, so both need an Enterprise deal.

Plan limits moved several answers. Chainstack’s wallet mix needs 34M request units, so Pro at $199 beats Growth plus overage. QuickNode’s indexer needs 69 requests per second at peak, above Build’s 50, and its trace job doubles credits, so both land on bigger plans. Tatum’s trace mix needs about 616M credits, four times its largest public plan.

eth_getLogs Block Range Limits

Indexers live on eth_getLogs, and the block range a single call can cover decides how many calls a backfill needs. Free plans are the tightest. Scanning one million blocks takes 200,000 calls at QuickNode Free trial limits and 100 calls on a 10,000-block paid plan.

Provider	Free plan	Paid plans	Other limits
Chainstack	100 blocks (Developer)	10,000 blocks on Growth, Pro, Business and Enterprise	Larger ranges on dedicated nodes
Alchemy	10 blocks	Unlimited on pay as you go and Enterprise	Responses capped at 150 MB
QuickNode	5 blocks (Free trial)	10,000 blocks	Per-method limits adjustable on request
Ankr	1,000 public, 3,000 Freemium	10,000 blocks (Premium)	Up to 200,000 logs per response
dRPC	100 blocks passed, 500 failed in our public test	Not published on its pricing page	Error cites a free-plan range limit
Infura	No block cap published	No block cap published	10,000 results, 10 seconds and 5,000 parameters per query
GetBlock	Not published	Not published	Ask before a large backfill
Tatum	Not published	Not published	Ask before a large backfill

Free Tier Archive Allowance

Free tiers decide where prototypes start, and archive access is the line that separates them. We converted each free allowance into archive eth_getBalance calls at each vendor’s own rate.

Provider	Free plan	Archive on free?	Archive balance reads
Alchemy	30M CU a month, 15 rps	Yes	About 1.5M a month
dRPC	210M CU, 100 rps, public nodes	Yes	About 10M requests
Ankr	200M credits, 30 rps	Yes, full and archive	About 1M a month
QuickNode	10M credits, 15 rps, one-month trial	Yes, on all plans	About 500,000
Tatum	100,000 credits, 3 rps	Yes, full history	About 50,000
Infura	3M credits a day, 500 per second	Yes, full archive data	About 37,500 a day
GetBlock	50,000 CU a day, 20 rps	Limited	About 1,250 a day
Chainstack	3M RU, 25 rps	No, from Growth	None

Our Public Endpoint Archive Test

Free public Ethereum endpoints are useful for scripts, so we tested which ones actually serve archive data. On 25 October 2026 we called eth_getBalance on the Ethereum Foundation’s original address at the latest block, 1,000 blocks back, block 1,000,000 and block 46,147, then tried eth_getLogs and an old debug_traceTransaction. Only dRPC and Tenderly returned balances from 2015 blocks, and only dRPC also returned a debug trace.

Public endpoint	Latest block	1,000 back	Block 1,000,000	Block 46,147	eth_getLogs	Old debug trace
dRPC (eth.drpc.org)	OK, 107 ms	OK, 98 ms	OK, 122 ms	OK, 103 ms	100 blocks OK, 500 rejected	OK
Tenderly gateway	OK, 183 ms	OK, 135 ms	OK, 179 ms	OK, 176 ms	1,000 blocks OK	Rate limited (429)
PublicNode	OK, 124 ms	403	403	403	1,000 blocks OK	Method not available
Ankr public	Needs an API key
NOWNodes public	Error 422

Public endpoints carry no SLA and change their rules without notice. Ankr’s public endpoint now requires a free API key, which is still a fair trade for its 3,000-block Freemium log range. Treat any public URL as a fallback for scripts, never as production infrastructure.

Latency on Ethereum Mainnet

OpenChainBench probes keyed Ethereum endpoints for QuickNode, GetBlock, Chainstack and others with eth_getBlockByNumber from three regions, and ranks public endpoints separately. Alchemy is listed but fell below the 50% success floor in the keyed cohort. QuickNode posted a 6.0 ms keyed median, GetBlock 8.8 ms with the tightest p99 at 16.8 ms, and Chainstack 17.0 ms.

Among public endpoints, dRPC led at 32.2 ms, ahead of PublicNode at 73.5 ms and Tenderly at 115.8 ms. Infura, Ankr and Tatum keyed endpoints are not in this benchmark, so test them from your own region. Note that this benchmark measures head-of-chain block reads, and archive calls are usually slower.

1. Chainstack

Chainstack runs Global Nodes and dedicated nodes across more than 70 chains and bills Ethereum in request units. Head calls cost 1 RU and archive calls 2 RU, which still leaves it among the cheapest archive meters. Growth costs $49 a month for 20M request units with archive data, or $4.90 per million archive calls.

• Plans: Developer free (3M RU, 25 rps, no archive), Growth $49 (20M RU, 250 rps, archive data), Pro $199 (80M, 400 rps), Business $499 (200M, 600 rps), Enterprise from $990 (400M). Annual billing saves 16%.
• Archive rules: 2 RU for calls 127 or more blocks behind the tip and 2 RU for all debug and trace calls. eth_getLogs covers 10,000 blocks on paid plans and 100 on Developer, per its limits page.
• Strengths: second-lowest bill in all three workloads, SOC 2 Type II and ISO 27001 on its security page, and a 99.99%+ uptime claim.
• Weaknesses: no archive on the free plan, and Growth overage of $15 per million RU doubles to $30 per million archive calls.

2. Alchemy

Alchemy pairs node access with SDKs, webhooks and data APIs, and serves archive data on every plan at no extra compute units. Its method weights make balance reads cheap and log queries costly. Its free tier includes full archive data and 30M compute units a month, about 1.5M archive balance reads.

• Plans: Free (30M CU a month, 15 rps), Pay as you go at $0.525 per 1M CU from 300 rps with Parity trace and Geth debug, and Enterprise with signed SLAs.
• Ethereum meter: 20 CU for eth_getBalance and block reads, 26 for eth_call, 40 for debug_traceTransaction and 60 for eth_getLogs, per its CU table.
• Strengths: the best free archive tier here, no eth_getLogs block cap on pay as you go, and SOC 2 Type II on its trust page.
• Weaknesses: $31.50 per million log queries, which put our indexer backfill at $1,386 a month, and support targets of 48 hours on Free and 24 hours on pay as you go.

3. dRPC

dRPC is a decentralized RPC network that routes calls across many node operators and charges the same for every method, so archive, log and trace calls cost no more than a head read. All methods cost a flat 20 compute units, and Pro draws only 16 CU per request from its pool.

• Plans: Free on public nodes (210M CU, about 10M requests, 100 rps, archive and debug included), Pro $49 (163M CU, about 10M requests), Scale $199 (664M CU, about 47M requests), Enterprise from $990. Pay as you go costs $6 per million requests.
• Archive: its archive node docs describe archive nodes on popular networks, and our public endpoint test returned balances from block 46,147 and an old debug trace.
• Strengths: lowest bill in all three of our archive workloads, a 99.96% uptime claim and 120+ chains.
• Weaknesses: no audit report on its own pages, the free tier runs on public nodes only, and paid eth_getLogs ranges are not published on its pricing page.

4. QuickNode

QuickNode runs a global node network with marketplace add-ons and the widest audit list in this group. It includes archive data on every plan and bills 20 credits per Ethereum call. QuickNode posted the lowest keyed median latency on Ethereum, 6.0 ms on OpenChainBench.

• Plans: Free trial (10M credits for one month, 15 rps), Build $49 (80M, 50 rps), Accelerate $249 (450M, 125 rps), Scale $499 (950M, 250 rps), Business from $999 (2B, 500 rps). Annual billing cuts Build to $34.
• Ethereum meter: 20 credits per call, 40 for trace and debug from Build up, and four times for trace_replay*, per its API credit page. eth_getLogs covers 5 blocks on Free and 10,000 on paid plans.
• Strengths: SOC 1 Type 2, SOC 2 Type 2 and ISO 27001 on its security page, archive even on the free trial, and overage from $0.62 down to $0.50 per million credits.
• Weaknesses: the free tier is a one-month trial, Build allows only 50 rps, and archive calls cost $12.25 per million on Build, two and a half times Chainstack.

5. GetBlock

GetBlock sells shared and dedicated nodes and multiplies a base compute unit by chain, method and archive status. Ethereum uses a 20x chain multiplier, and archive endpoints double it. An archive call on GetBlock costs 40 CU and an archive debug trace 80 CU.

• Plans: Free (50,000 CU a day, limited archive), Starter $49 (90M CU, 250 rps), Growth $99 (185M), Advanced $199 (385M), Scale $349 (700M), Pro $499 (1B CU, 800 rps), Premium $699 (1.6B). Annual billing cuts Starter to $39.
• Archive rules: an archive modifier of 2 on archive endpoints, per its CU formula. Dedicated archive nodes start at $1,500 a month and full nodes at $1,000.
• Strengths: the tightest Ethereum p99 on OpenChainBench at 16.8 ms, SOC 2 Type II attested in Q2 2026, and a stated support response under 5 minutes.
• Weaknesses: $21.78 per million archive calls on Starter, no published overage below Pro, and no published eth_getLogs range.

6. Ankr

Ankr runs a large multi-chain RPC network on prepaid credits with a high rate ceiling. Every EVM request costs the same, and archive data is on all plans. EVM calls cost $0.02 per 1,000 requests, or $20 per million, at up to 1,500 requests per second.

• Plans: Freemium (200M credits a month, about 1M requests, 30 rps), Pay as you go from $10 per 100M credits, and Deal at $500 for 6B credits, about 30M requests with 20% extra.
• Archive and logs: full and archive data on Public, Freemium and Premium, and eth_getLogs ranges of 1,000, 3,000 and 10,000 blocks, per its service plans page. Trace and debug need Premium.
• Strengths: the highest rate limit here, flat pricing across methods, and SOC 2 Type II through its operator Asphere on its trust page.
• Weaknesses: $20 per million is four times dRPC’s flat rate, and no independent keyed latency data.

7. Infura

Infura is a long-running Ethereum API with a daily credit quota and full archive data on every plan, including the free Core tier. Archive calls cost the same as head calls for now. Infura charges 255 credits for eth_getLogs and 1,000 for debug calls, against 80 for a balance read.

• Plans: Core free (3M credits a day, 500 per second), Developer $50 (15M a day, 4,000 per second, debug and trace), Team $225 (75M a day, 40,000 per second), Enterprise custom. An add-on sells 55M credits for $200 a month.
• Archive rules: requests older than 128 blocks cost the same credits as recent ones, though its credit cost page says this might change. eth_getLogs is capped at 10,000 results and 10 seconds per query.
• Strengths: archive data on the free tier and a cheap rate for archive balance reads at $8.89 per million.
• Weaknesses: a daily quota that our wallet mix breaks on busy days, $111.11 per million debug traces, and no SOC 2 or ISO 27001 report on its pages.

8. Tatum

Tatum bundles RPC nodes with notifications, data APIs and wallet tooling, priced by a monthly credit slider. Its docs say it keeps full Ethereum history from genesis. A debug or trace call costs 50 credits on Tatum, or $612.50 per million on Starter.

• Plans, billed monthly: Free (100,000 credits, 3 rps), Starter $49 (4M credits) or $79 (7M), Pro $139 (15M) or $349 (40M), Scale $1,199 (150M), all paid plans at 200 rps, per its plan limits.
• Ethereum meter: 2 credits for standard calls, 5 for eth_call and 50 for debug_* and trace_*, per its RPC docs, which flag archive methods as possibly costing more.
• Strengths: SOC 2 Type II and ISO 27001 on its security page, and cheap archive balance reads at 2 credits.
• Weaknesses: the highest bill for wallet history at $1,199, no public plan big enough for trace forensics, and no published eth_getLogs range.

Providers We Left Out

Helius scores 7.0 in our main ranking but serves Solana only. Dwellir posted a 35.3 ms keyed median on OpenChainBench but is not yet in our scored set. NOWNodes, CDP Node and Lava scored lower on the same weights, and none of them published a clear Ethereum archive policy we could verify on 25 October 2026. Their entries sit in our RPC node provider ranking.

Self-hosting is the other route. An Erigon archive node needs about 2 TB of fast NVMe storage and growing, plus a consensus client and regular upgrades. Our dedicated nodes hub covers when a dedicated or self-run archive node beats shared plans.

Final Ranking

Chainstack wins on our weights because it pairs one of the lowest archive rates with audits. Alchemy is close behind for its free archive tier and tooling, and dRPC leads on raw price. QuickNode and GetBlock trade price for speed and consistency.

1. Chainstack, 8.4: best overall archive value with SOC 2 Type II and ISO 27001.
2. Alchemy, 8.3: best free archive tier, costly for logs.
3. dRPC, 8.2: cheapest flat meter for archive, logs and traces.
4. QuickNode, 8.1: lowest latency, archive on every plan and the widest audit set.
5. GetBlock, 7.6: tightest p99 and published dedicated archive pricing.
6. Ankr, 6.3: highest rate limit on prepaid credits.
7. Infura, 6.1: free archive data, held back by a daily quota.
8. Tatum, 6.1: full history and audits, expensive traces.

How to Test Archive Endpoints in One Week

A week of side-by-side traffic answers what a pricing page cannot. Send the same archive queries to two or three candidates from the region where your servers run. Log median and tail latency, error codes and whether each endpoint returns the same balance at the same old block.

for url in "$CHAINSTACK_URL" "$DRPC_URL" "$QUICKNODE_URL"; do
  curl -s -w " %{time_total}s\n" \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance","params":["0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe","0xF4240"]}' \
    "$url"
done

Block 0xF4240 is block 1,000,000, so a node without archive data returns an error instead of a balance. Repeat the loop with an eth_getLogs call at your real block range and a debug_traceTransaction on an old hash before you commit to a plan.

Frequently Asked Questions