8 Best Infura Alternatives in 2026 for Ethereum and L2 Apps

Last updated: 25 October 2026 · Prices, method costs, quotas and benchmark figures rechecked on vendor pages on 25 October 2026

The best Infura alternatives in 2026 are Chainstack for overall value, Alchemy for its free tier and developer tooling, and dRPC for the cheapest flat meter. We ranked eight providers on the same six weighted criteria as our main RPC ranking, priced three Ethereum and L2 workloads on every meter, and mapped what changes when you leave Infura’s daily credit quota.

Most teams start looking for Infura alternatives when the daily quota bites. Infura bills 80 credits for a standard call and 255 for eth_getLogs, and once a day’s credits run out it returns 402 errors and drops WebSocket connections until the reset. This guide expands the Infura entry in our ranking of the 12 best RPC node providers, and our methodology page explains how we collect prices and screenshots. If Alchemy is also on your list, our Alchemy alternatives guide covers the same providers from the other side, and our QuickNode vs Alchemy vs Chainstack comparison puts the top three side by side.

The Decision Kernel

Pick the replacement by the reason you are leaving. A team hitting the daily quota needs a monthly meter and a team paying 255 credits per log query needs a flat meter. Export one week of Infura usage by method and network before you compare any plan. The shortcuts below cover the common cases.

• Lowest bill with audits: Chainstack, which charges 1 request unit for most Ethereum calls and states SOC 2 Type II and ISO 27001.
• Free tier and tooling: Alchemy, with 30M compute units a month free and a SOC 2 Type II trust page.
• Cheapest log-heavy and trace-heavy traffic: dRPC, which bills every method at a flat 20 compute units.
• Lowest measured latency: QuickNode on warm connections and GetBlock on cold starts, per OpenChainBench on 25 October 2026.
• Widest audit set: QuickNode, which lists SOC 1 Type 2, SOC 2 Type 2 and ISO 27001.
• Simple per-request billing in euros: NOWNodes, where every call counts as one request.

How We Ranked the Infura Alternatives

We scored each provider from 1 to 5 on six criteria, weighted them and doubled the total. The weights and scores match our 12-provider RPC ranking, so Infura sits on the same scale as its rivals. Every price, quota and audit claim links to a vendor page checked on 25 October 2026. The full process is on our methodology page.

• Price per call, 25%: the monthly bill for Ethereum and L2 method mixes, converted from each vendor’s 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%: debug and trace APIs, archive data, WebSockets, dedicated nodes and data APIs.
• Coverage, 15%: Ethereum L2s and other chains on one account.
• Free tier, 10%: how many Ethereum calls a team can make before paying.

Provider	Price (25%)	Reliability (20%)	Compliance (15%)	Features (15%)	Coverage (15%)	Free tier (10%)	Score
Chainstack	5	4	5	4	4	3	8.6
Alchemy	3	4	4	5	5	5	8.3
dRPC	5	4	2	3	5	4	7.9
GetBlock	3	5	4	4	5	2	7.8
QuickNode	3	4	5	5	4	2	7.7
Ankr	2	3	4	3	4	4	6.3
Tatum	1	3	5	4	5	1	6.1
NOWNodes	4	3	1	2	5	1	5.8
Infura (baseline)	4	3	1	3	3	4	6.1

Why Teams Move Off Infura

Infura is a long-running Ethereum API with a fair free tier and 25 mainnets on its endpoints list. Its pricing has three traits that push growing teams elsewhere. The quota resets daily, so one busy day can stop your app even when the monthly total is fine. The credit cost table also weights log, trace and receipt calls heavily.

• Plans: Core free (3M credits a day, 500 credits per second), Developer $50 a month (15M a day, 4,000 per second), Team $225 (75M a day, 40,000 per second), Enterprise custom. An add-on sells 55M more credits for $200 a month.
• Method weights: 80 credits for eth_call, eth_getBalance and most reads, 255 for eth_getLogs, 300 for eth_estimateGas and trace_*, and 1,000 for eth_getBlockReceipts and debug_*.
• At the limit: requests past the daily quota return unbilled 402 errors, and WebSocket connections are severed until the quota resets.
• Gaps: Debug and Trace start on Developer, Solana access is for select customers only, and we found no SOC 2 or ISO 27001 report on Infura’s pages.

Infura Alternatives at a Glance

The table lines up each provider’s billing unit, what an eth_call and an eth_getLogs cost in that unit, 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	eth_call / eth_getLogs	Entry paid plan	Rate limit
Infura	Credits per day	80 / 255	Developer $50: 15M credits a day	4,000 credits per second
Chainstack	Request units (RU)	1 / 1, 2 for archive	Growth $49: 20M RU	250 rps
Alchemy	Compute units (CU)	26 / 60	Pay as you go: $0.525 per 1M CU	300 rps
dRPC	Compute units	20 / 20, 16 inside the Pro pool	Pro $49: 163M CU, about 10M requests	300 rps
GetBlock	Compute units	20 / 20 on Ethereum	Starter $49: 90M CU	250 rps
QuickNode	API credits	20 / 20 on Ethereum	Build $49: 80M credits	50 rps
Ankr	API credits	$0.02 per 1,000 EVM requests	Pay as you go from $10	1,500 rps
Tatum	Credits	5 / 2	Starter $49: 4M credits	200 rps
NOWNodes	Requests	1 / 1	Pro €20: 1M requests	15 rps on the free plan

What One Million Calls Cost by Method

Converting each unit to dollars shows how far apart the meters sit. We used the entry paid plan fully used, which is what a small team pays. A million debug traces cost $111.11 on Infura Developer and $4.81 on dRPC Pro. NOWNodes is converted at the ECB rate of $1.1193 per euro from 23 October 2026.

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

Two caveats change these numbers for real traffic. Chainstack bills a call as archive, at 2 RU, when it targets a block 127 or more behind the tip, and it judges eth_getLogs by its fromBlock. Alchemy and Infura weight receipts and traces differently, so a mix with many eth_getBlockReceipts calls costs 1,000 credits each on Infura against 20 CU on Alchemy.

What Three Ethereum and L2 Workloads Cost

We built three common method mixes across Ethereum, Base and Arbitrum, converted each into every vendor’s unit and picked the cheapest public plan that covers the volume and a peak of three times the average rate. Chainstack had the lowest bill in two of three workloads, and dRPC won the trace-heavy one at $108.

Provider	dApp backend, 15M	Event indexer, 60M	Trace analytics, 20M
Infura	$225 (Team, busy days over quota)	Enterprise quote	Enterprise quote
Chainstack	$49 (Growth)	$199 (Pro)	$169 (Growth)
Alchemy	$198 (Pay as you go)	$1,244 (Pay as you go)	$399 (Pay as you go)
dRPC	$78 (Pro)	$274 (Scale)	$108 (Pro)
GetBlock	$199 (Advanced)	$699 (Premium)	$349 (Scale)
QuickNode	$185 (Build)	$632 (Scale)	$311 (Accelerate)
Ankr	$300 (Pay as you go)	$1,100 (Deal ($500))	$400 (Pay as you go)
Tatum	$1,199 (Scale 150M)	$1,199 (Scale 150M)	Quote, above public plans
NOWNodes	$224 (Business)	$448 (Business Plus)	$224 (Business)

• dApp backend, 15M requests: 35% eth_call, 15% eth_getBalance, 10% each of eth_blockNumber, receipts and eth_getLogs, and 5% each of gas estimates, sends, block reads and eth_chainId.
• Event indexer, 60M requests: 50% eth_getLogs, 25% eth_getBlockByNumber, 10% eth_getBlockReceipts, 10% receipts and 5% eth_blockNumber, all on recent blocks.
• Trace analytics, 20M requests: 30% debug_traceTransaction, 10% trace_block, 30% eth_getLogs, 20% block reads and 10% receipts.

The Infura numbers come from its daily quota. The dApp backend averages 104.8 credits per request, or about 52M credits a day, and a day at 1.5 times the average needs about 79M, above Team’s 75M. The indexer averages 519M credits a day and the trace job 287M, so both need an Enterprise deal or stacked add-ons.

Plan limits changed a few answers. Tatum needs 45.75M credits for the dApp backend, just above its 40M Pro tier, so the cheapest public fit is Scale at $1,199. A backfilling indexer that reads old blocks would pay 2 RU per call on Chainstack, which lifts its bill from $199 to $499 on Business.

L2 Coverage and Chain Multipliers

Most Infura alternatives cover the main Ethereum L2s, but two of them price L2 calls differently from Ethereum. On GetBlock, one million eth_call requests on Scroll cost five times what they cost on Ethereum. The coverage table checks eight networks against each vendor’s own chain list.

Provider	Ethereum	Base	Arbitrum	OP Mainnet	Polygon	Linea	ZKsync Era	Scroll
Infura	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Chainstack	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Alchemy	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
dRPC	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
GetBlock	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
QuickNode	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Ankr	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Yes
Tatum	Yes	Yes	Yes	Yes	Yes	Not listed	Yes	Yes
NOWNodes	Yes	Yes	Yes	Yes	Yes	Yes	Yes	Not listed

Network	Infura credits	QuickNode credits	GetBlock CU	QuickNode Build, per 1M calls	GetBlock Starter, per 1M calls
Ethereum, Base, Arbitrum, OP Mainnet, Polygon, Linea	80	20	20	$12.25	$10.89
ZKsync Era	80	30	80	$18.38	$43.56
Scroll	80	30	100	$18.38	$54.44

Chainstack, Alchemy, dRPC, Ankr and NOWNodes bill the same unit on every EVM chain we checked. GetBlock’s CU rules also double the count for archive endpoints and for debug and trace methods, and QuickNode doubles credits for trace and debug calls.

Migration Effort From Infura

Moving off Infura is mostly an endpoint swap, since every provider here serves standard Ethereum JSON-RPC. The work sits in quotas, method weights and network gaps. Plan for a monthly meter: a busy day now draws down a month of usage instead of hitting a daily wall. The table rates the effort for a typical Ethereum and L2 app.

Provider	Quota model	At the limit	Debug and trace	Network gaps	Effort
Chainstack	Monthly RU	Overage from $15 down to $5 per 1M RU	2 RU per call	None in our set	Low
Alchemy	Monthly CU, pay as you go	Billed per CU	Pay as you go and up	None in our set	Low
dRPC	Monthly CU pool	$6 per 1M requests	Flat 20 CU	None in our set	Low
GetBlock	Monthly CU	Top up or change plan	2x CU	ZKsync 4x and Scroll 5x Ethereum CU	Medium
QuickNode	Monthly credits	$0.62 down to $0.50 per 1M credits	2x credits	ZKsync and Scroll at 1.5x	Low
Ankr	Prepaid credits	Top up the balance	Listed on paid plans	None in our set	Low
Tatum	Monthly credits	Move up a plan	50 credits per call	Linea not listed	Medium
NOWNodes	Monthly requests	€5 down to €0.5 per 100,000	1 request per call	Scroll not listed	Medium

Infura puts the key in the URL path, as in https://mainnet.infura.io/v3/KEY, and most rivals do the same with their own hostnames. Alchemy, for example, uses https://eth-mainnet.g.alchemy.com/v2/KEY. Keep the URL in one environment variable, then swap and test it.

# before
export RPC_URL="https://mainnet.infura.io/v3/$INFURA_KEY"
# after: paste the HTTPS endpoint from the new provider dashboard
export RPC_URL="$NEW_PROVIDER_ETH_URL"
curl -s -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' \
  "$RPC_URL"

Infura’s Gas API is an Infura add-on outside the JSON-RPC spec, so apps that call it need eth_feeHistory or the new vendor’s own gas tooling. Check eth_getLogs block-range limits on the new plan as well, since each vendor caps ranges differently.

Latency on Ethereum, Base and Arbitrum

OpenChainBench probes API-key endpoints for QuickNode, Chainstack and GetBlock every few minutes from three regions, with matching boards for Base and Arbitrum. Alchemy is listed but fell below the 50% success floor. QuickNode had the lowest warm median on all three chains, and GetBlock the lowest cold-start median.

Provider	Ethereum	Base	Arbitrum
QuickNode	6.6 ms warm, 29.7 ms cold	5.4 ms warm, 29.1 ms cold	5.6 ms warm, 30.3 ms cold
Chainstack	16.6 ms warm, 68.0 ms cold	5.7 ms warm, 28.4 ms cold	6.6 ms warm, 66.8 ms cold
GetBlock	8.8 ms warm, 26.8 ms cold	8.8 ms warm, 22.2 ms cold	8.1 ms warm, 24.0 ms cold

The free public endpoints are far slower. Public dRPC posted 32.6 ms on Ethereum, 111.8 ms on Base and 39.4 ms on Arbitrum, and the public NOWNodes Ethereum endpoint posted 129.7 ms. Infura, Ankr and Tatum are not tracked, so test them from your own region.

1. Chainstack

Chainstack runs Global Nodes and dedicated nodes across more than 70 chains and bills in request units. A recent-block Ethereum or L2 call costs 1 RU whatever the method. Growth costs $49 a month for 20M request units at 250 requests per second, the lowest included rate on this list.

• Plans: Developer free (3M RU, 25 rps), Growth $49 (20M, 250 rps), Pro $199 (80M, 400 rps), Business $499 (200M, 600 rps), Enterprise from $990 (400M). Annual billing saves 16%.
• Ethereum and L2 meter: 1 RU for full requests, 2 RU for archive calls 127 or more blocks behind the tip, and 2 RU for all debug_* and trace_* methods, per its request unit rules.
• Strengths: lowest bill in two of our three workloads, SOC 2 Type II and ISO 27001, a 99.99%+ uptime claim, and all eight networks in our L2 set.
• Weaknesses: overage of $15 per 1M RU on Growth, six times the included rate, and log backfills bill as archive.

2. Alchemy

Alchemy pairs node access with SDKs, webhooks and data APIs, and weights each method in compute units. Basic reads are cheap and log queries are not. Its free tier gives 30M compute units a month, or about 1.15M eth_call requests, with no time limit.

• Plans: Free (30M CU a month, 15 rps), Pay as you go at $0.525 per 1M CU from 300 rps with Debug and Trace, and Enterprise with signed SLAs and larger eth_getLogs ranges.
• Ethereum meter: 10 CU for eth_blockNumber, 20 for balances, receipts and gas estimates, 26 for eth_call, 40 for sends and debug_traceTransaction, and 60 for eth_getLogs, per its CU table.
• Strengths: the largest permanent free tier here, SOC 2 Type II on its trust page, and all eight networks in our L2 set.
• Weaknesses: $31.50 per million log queries, the highest rate here, which put our indexer at $1,244 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. That makes it the opposite of Infura’s weighted meter. All RPC 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, 100 rps), Pro $49 (163M CU, about 10M multi-chain requests, 300 rps), Scale $199 (664M CU, about 47M requests, 600 rps), Enterprise from $990. Pay as you go costs $6 per 1M requests.
• Ethereum meter: $0.30 per 1M CU on its compute unit page, so traces, logs and receipts all cost the same as a balance check.
• Strengths: cheapest bill for trace analytics at $108, a 99.96% uptime claim, 120+ chains and every network in our L2 set.
• Weaknesses: no audit report on its own pages, and the free tier uses public nodes only.

4. GetBlock

GetBlock sells shared and dedicated nodes for 130+ chains and multiplies a base compute unit by chain and method. Ethereum and most L2s use a 20x chain multiplier. ZKsync Era calls cost 80 CU and Scroll calls 100 CU, four and five times an Ethereum call.

• Plans: Free (50,000 CU a day), 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.
• Method rules: debug and trace calls count double, trace_replayTransaction four times, and archive endpoints double again.
• Strengths: lowest cold-start medians on Ethereum, Base and Arbitrum, the tightest p99 on Ethereum at 16.6 ms, and SOC 2 Type II.
• Weaknesses: steep L2 multipliers, no published overage rate, and a free tier of about 2,500 Ethereum calls a day.

5. QuickNode

QuickNode runs a global node network with marketplace add-ons and the widest audit list in this group. It bills 20 credits per method on Ethereum and the main L2s. It posted the lowest warm median latency on Ethereum, Base and Arbitrum 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 and L2 meter: 20 credits per call on Ethereum, Base, Arbitrum, Optimism, Polygon and Linea, 30 on Scroll and ZKsync, and double for trace and debug, per its API credit pages.
• Strengths: SOC 1 Type 2, SOC 2 Type 2 and ISO 27001 on its security page, warm medians of 5.4 to 6.6 ms, and overage from $0.62 down to $0.50 per 1M credits.
• Weaknesses: Build allows only 50 rps, and the free tier is a one-month trial.

6. Ankr

Ankr runs a large multi-chain RPC network with prepaid credits and a high rate limit. Every EVM request costs the same. EVM calls cost $0.02 per 1,000 requests, or $20 per million, at 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, Deal from $500 for 6B credits, about 30M requests with 20% extra.
• Coverage: 75+ chains on paid plans, with all eight networks in our L2 set on its chain list.
• Strengths: the highest public 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 the highest flat EVM rate in this list, and no independent keyed latency data.

7. Tatum

Tatum bundles RPC nodes with notifications, data APIs and an AI builder, priced by a monthly credit slider. Its meter is cheap for standard reads and expensive for traces. A debug or trace call costs 50 credits, ten times an eth_call.

• 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 at 200 rps. Two-year billing cuts Starter to $25 a month.
• Ethereum meter: 2 credits for standard calls, 5 for eth_call and 50 for debug_* and trace_*, per its RPC docs.
• Strengths: SOC 2 Type II and ISO 27001 on its security page, and broad chain coverage.
• Weaknesses: the highest bill for our dApp backend, no public plan big enough for the trace workload, no overage on current plans, and Linea is not on its supported list.

8. NOWNodes

NOWNodes sells shared node access to many chains priced per request in euros, with no method weights. That makes bills easy to predict. Pro Plus costs 90 euros for 10M requests, about $10.07 per million calls of any type.

• Plans: Start free (100,000 requests, 15 rps, five networks, one month), Pro €20 (1M), Pro Plus €90 (10M), Business €200 (30M), Business Plus €300 (50M), Enterprise €500 (100M). Annual billing saves 10%.
• Overage: €5 per 100,000 requests on Pro Plus, €1 on Business and Business Plus, €0.5 on Enterprise.
• Strengths: flat per-request pricing, a stated 3-minute support response and third place in two of our workloads.
• Weaknesses: no audit report found, Scroll is not on its nodes list, and its public Ethereum endpoint posted 129.7 ms on OpenChainBench.

Providers We Left Out

Helius scores 7.0 in our main ranking but serves Solana only, so it cannot replace an Ethereum or L2 endpoint. CDP Node and Lava scored 4.4 and 4.3 on the same weights, below every pick here. Their full entries sit in our RPC node provider ranking.

Self-hosting is the other route off Infura. An Ethereum full node needs fast NVMe storage, two clients and constant upgrades, and an archive node needs far more. Our RPC providers hub covers when shared plans stop paying off.

Final Ranking

Chainstack wins on our weights because it pairs the lowest included rate with audits and full L2 coverage. Alchemy is close behind for its free tier and tooling, and dRPC leads on raw price for heavy methods. GetBlock and QuickNode trade price for speed.

1. Chainstack, 8.6: best overall value with SOC 2 Type II and ISO 27001.
2. Alchemy, 8.3: best free tier and tooling, costly for logs.
3. dRPC, 7.9: cheapest flat meter for logs and traces.
4. GetBlock, 7.8: best cold-start latency, steep ZKsync and Scroll rates.
5. QuickNode, 7.7: lowest warm latency and the widest audit set.
6. Ankr, 6.3: highest rate limit on prepaid credits.
7. Tatum, 6.1: data APIs and audits, expensive traces.
8. NOWNodes, 5.8: simple per-request billing in euros.

How to Test Infura Alternatives in One Week

A week of side-by-side traffic answers what a pricing page cannot. Keep Infura live and mirror a share of reads to two candidates from the region where your servers run. Log median and tail latency, error rates and the block number each endpoint returns, then price that week’s method mix on each meter.

for url in "$INFURA_URL" "$CHAINSTACK_URL" "$QUICKNODE_URL"; do
  curl -s -o /dev/null -w "%{time_total}\n" \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' \
    "$url"
done

Run the loop from a long-lived server and from a serverless function to see warm and cold behavior. Repeat it on Base and Arbitrum endpoints, and compare returned block numbers to spot lagging nodes before you cut over.

Frequently Asked Questions