RPC Node Providers Compared: Alchemy, QuickNode, Infura, Chainstack

RPC Node Providers Compared: Alchemy, QuickNode, Infura, Chainstack

Reviewed by Jordan Paul · November 18, 2026 · 14 min read

Quick Answer

No RPC provider is cheapest everywhere. On a stated mix of 60% eth_call, 25% eth_getBalance and 15% eth_getLogs, Chainstack's flat one-unit pricing works out lowest at $2.45 per million calls when its Growth plan is fully used, against roughly $10 to $20 for the other five providers, as of 18 November 2026.

LiveBTC—·ETH—·Gas—via CoinGecko

The best RPC provider depends on what you call, and that is why price pages mislead. An RPC provider sells you access to blockchain nodes over JSON-RPC, and the four best-known ones, Alchemy, QuickNode, Infura and Chainstack, each bill in a different unit. This guide converts six providers to cost per million calls on one stated request mix, shows the arithmetic, and ranks them on documented pricing, checked on 18 November 2026.

It is an editorial synthesis, not a lab test. Every figure comes from the provider's own pricing page or method-weight documentation, fetched on 18 November 2026, and none of this was benchmarked by us. If you are new to the underlying idea, our explainer on what a blockchain node is covers the basics.

How We Compared These RPC Providers

Rank is merit-based, and no provider paid for inclusion or position. Each provider is scored 0 to 10 on five criteria, and the weights below are identical for every entry.

CriterionWeightHow it is scored
---------
Cost per million calls on the stated mix35%Banded: up to $5 scores 10; $5 to $10 scores 8; $10 to $13 scores 6; $13 to $17 scores 5; $17 to $25 scores 3
Free-tier usefulness20%Recurring monthly calls on the stated mix: 3 million or more scores 9 or 10; about 1 million scores 7; about 0.85 million scores 5; under 0.5 million scores 3; one-time trial only scores 2
Chain, archive and trace coverage15%What the pricing page states about archive data, trace and debug access, and plan gating
Throughput at the entry paid tier15%Calls per second at the stated mix: 200 or more scores 9 or 10; 50 scores 5; under 40 scores 4; not stated scores 3
Pricing transparency15%Published per-method weights, overage rates and absence of contradictions on the vendor's own pages

Reliability is deliberately not scored. Uptime and latency numbers on vendor sites are vendor-stated, and no independent measurement was used here, so they carry no weight. Where this guide quotes such a claim, it is labeled as the vendor's own.

The request mix used for every calculation

The mix is an assumption, not a measured average: 60% eth_call, 25% eth_getBalance and 15% eth_getLogs, all against recent blocks on Ethereum mainnet. That resembles a read-heavy dApp front end that checks balances, reads contract state and occasionally pulls event logs. Trace and debug calls are excluded because plans gate them differently. Your own mix will move the results, so the per-method weights are listed for you to rerun the sums.

MethodAlchemy (CU)QuickNode (credits)Infura (credits)Chainstack (RU)Ankr (credits)Coinbase CDP (BU)
---------------------
eth_call262080120030
eth_getBalance202080120030
eth_getLogs60202551200100

Sources for the weights are Alchemy's compute unit costs, QuickNode's Ethereum API credits, Infura's credit costs, Chainstack's request units, Ankr's service plans and Coinbase's CDP Node pricing. Chainstack counts 1 request unit for a full-node request and 2 for archive, set by block age, so recent-block calls are 1.

Which Is the Best RPC Provider?

Chainstack ranks first on this scoring, with 92 out of 100, because it charges one request unit per call regardless of method and gives the largest recurring free tier. Alchemy is second at 67.5, helped by high throughput and a simple pay-as-you-go rate. The gap is partly a function of the mix: a trace-heavy workload would reorder the table.

RankProviderCostFree tierCoverageThroughputTransparencyScore
------------------------
1Chainstack10989992.0
2Alchemy57710767.5
3Ankr37710963.5
4QuickNode6295858.0
5Infura6574453.5
6Coinbase CDP Node3353739.0

Scores are each criterion's 0 to 10 mark multiplied by its weight, summed to 100. Example for Alchemy: (5 x 35 + 7 x 20 + 7 x 15 + 10 x 15 + 7 x 15) / 10 = 67.5.

Why Can't You Compare RPC Provider Prices Directly?

Because each vendor sets its own unit and its own per-method weight. Alchemy's eth_call costs 26 compute units, QuickNode's costs 20 credits, Infura's 80 credits, Ankr's 200 credits and Coinbase's 30 billing units, while Chainstack counts one request unit. A cheaper-looking price per million units can still be the dearer provider per call.

1. Chainstack — Best for predictable per-call pricing

Best for: teams that mix cheap and heavy methods and want one number per call.

Chainstack's pricing page lists a free Developer plan, then Growth, Pro, Business and Enterprise tiers, billed in request units. Its newest changelog entry fetched on 18 November 2026 is dated 12 November 2026 and concerns Ethereum Hoodi Global Nodes following the Fast Confirmation Rule for the safe block tag.

  • Newest plan structure (18 November 2026): Developer $0 with 3 million RU and 25 RPS; Growth $49 a month with 20 million RU and 250 RPS; Pro $199 with 80 million and 400 RPS; Business $499 with 200 million and 600 RPS; Enterprise from $990 with 400 million. Annual billing lowers Growth to $40.
  • Pricing: 1 RU per full-node request and 2 RU per archive request; debug and trace methods are 2 RU. Overage per million RU is $20 on Developer, $15 on Growth, $12.50 on Pro, $10 on Business and $5 on Enterprise; pay-as-you-go starts from $2.50.
  • Limits: archive and debug and trace APIs are not on the free plan. The docs say Trader Nodes are being deprecated on 1 December 2026, so new builds should use Global Nodes.
  • Standout: on the stated mix one call is 1 RU, so Growth costs $49 / 20 million = $2.45 per million calls at full use.

Limitations: the $2.45 figure assumes you use the whole 20 million allowance; beyond it, Growth overage is $15 per million calls on this mix, higher than most rivals. Archive-depth eth_getLogs ranges bill at 2 RU.

2. Alchemy — Best for high throughput without a plan commitment

Best for: apps that want a single usage-based rate and generous concurrency.

Alchemy offers a Free plan, a pay-as-you-go plan billed in compute units and a custom Enterprise tier. Its pricing page carries no dates, but its changelog's newest entry, fetched 18 November 2026, is dated 12 November 2026 and covers Wallets, Data and Node sections without separate titles.

  • Newest plan structure (18 November 2026): Free with 30 million CU a month; Pay as You Go at $0.52 per million CU; Enterprise custom with signed SLAs.
  • Pricing: on the stated mix one call averages 29.6 CU, so a million calls costs 29.6 x $0.52 = $15.39. Pay-as-you-go has no included allowance.
  • Limits: Free allows 300 CU a second (15 requests a second) and 5 apps. Pay as You Go allows 10,000 CU a second (300 requests a second); extra 5,000 CU a second blocks cost $160 a month, to a self-serve ceiling of 30,000 CU a second.
  • Standout: Solana gRPC from $75 a TB is listed on the same page, alongside a gas sponsorship admin fee of 8%.

Limitations: the pricing page does not make clear which plans include the Trace and Debug APIs, so confirm with Alchemy before relying on them. Per-call cost on this mix is above QuickNode's and Infura's paid plans.

3. Ankr — Best for a flat, easy-to-model rate

Best for: developers who want every EVM method at one published price.

Ankr's service-plans page lists Public, Freemium, Premium and Enterprise tiers. It carries no date and its marketing pricing page returned a 403 error to our fetch, so this entry rests on the docs page. A changelog was not reachable, so no newest-version date is given.

  • Newest plan structure (18 November 2026): Freemium with 200 million API credits a month free; Premium pay-as-you-go at $0.10 per million credits with a $10 minimum deposit; a Deal tier of $500 to $3,000 a month that adds 20% extra credits; Enterprise custom.
  • Pricing: every EVM request is 200 credits, or $0.00002, so a million calls cost 200 million credits x $0.10 per million = $20.00. Free covers 200 million / 200 = 1 million calls a month.
  • Limits: Public and Freemium allow about 1,800 requests a minute; Premium is stated at up to roughly 1,500 requests a second per endpoint. That is a vendor-stated ceiling.
  • Standout: pricing does not vary by method, so debug and trace calls are charged the same 200 credits.

Limitations: because everything costs the same, cheap calls such as eth_getBalance are expensive relative to rivals. The page does not state archive or chain coverage, so check supported networks separately.

4. QuickNode — Best for archive access on every plan

Best for: teams that want archive data included and a clear ladder of paid tiers.

QuickNode bills in API credits, where a method's weight is a multiplier on each valid response. Its changelog, fetched 18 November 2026, lists a newest entry dated 16 November 2026 under Infrastructure Updated and Developer Resources Added, with no entry titles.

  • Newest plan structure (18 November 2026): free trial of 10 million credits for one month; Build $49 for 80 million; Accelerate $249 for 450 million; Scale $499 for 950 million; Business $999 for 2 billion; Business+ tiers from $1,499 to $2,999; Enterprise custom. Annual billing is 15% lower.
  • Pricing: the Ethereum page lists 20 credits for all standard methods, so a call is 20 credits. Build works out at $49 / 80 million = $0.6125 per million credits, or 20 x $0.6125 = $12.25 per million calls; Business is $999 / 2,000 million = $0.4995 per million credits, or $9.99 per million calls. Build overage is $0.62 per million credits.
  • Limits: requests a second rise from 15 on the trial to 50 on Build, 125, 250 and 500 on Business. Trace and Debug is available from Build upward, not on the trial.
  • Standout: archive data is included on every plan.

Limitations: there is no recurring free plan, only a one-month trial. Trace pricing is not itemized on the page.

5. Infura — Best for teams already in the MetaMask and Consensys stack

Best for: projects that already use MetaMask developer tooling and want a recognizable vendor.

Infura bills in credits with daily quotas. The pricing page is undated and we could not find a dated Infura changelog, so no newest-version date is given; the docs site returned errors for its changelog URLs on 18 November 2026.

  • Newest plan structure (18 November 2026): Core free with 3 million daily credits and 500 credits a second per its table; Developer $50 a month with 15 million daily credits and 4,000 credits a second; Team $225 a month with 75 million daily and 40,000 a second; Enterprise custom.
  • Pricing: on the stated mix one call is 0.6 x 80 + 0.25 x 80 + 0.15 x 255 = 106.25 credits. Over 30 days Developer has 450 million credits, so $50 / 450 = $0.1111 per million credits and $11.81 per million calls at full use; Team is $225 / 2,250 = $0.10, or $10.63. No per-credit overage rate is listed, only a $200 a month add-on for 55 million extra credits.
  • Limits: Developer's 4,000 credits a second equals about 37.6 calls a second at this mix.
  • Standout: the free tier includes full archive data and access to 40 or more networks.

Limitations: the page contradicts itself. The table gives the free plan 3 million daily credits and 500 credits a second, while the FAQ says 6 million and 2,000. Both are on https://www.infura.io/pricing, so check your dashboard. We scored on the table and the contradiction cost transparency points.

6. Coinbase CDP Node — Best for Base-centered builds that already use Coinbase tooling

Best for: teams building around Coinbase's developer platform.

CDP Node bills in billing units, or BU, with three method tiers. The pricing page is undated and the Coinbase developer changelog fetched on 18 November 2026 had no Node entries; its newest items were dated 23 October 2026 and concern Wallets and x402, so no newest-version date is given for Node.

  • Newest plan structure (18 November 2026): pay-as-you-go with 10 million BU free each month, then $0.50 per million BU. A payment method has been required since January 2026.
  • Pricing: eth_call and eth_getBalance cost 30 BU and eth_getLogs 100 BU, so a call averages 0.6 x 30 + 0.25 x 30 + 0.15 x 100 = 40.5 BU and a million calls cost 40.5 x $0.50 = $20.25. The free allowance covers 10 million / 40.5 = about 247,000 calls.
  • Limits: the page does not state rate limits or supported chains.
  • Standout: published per-method tiers: 30 BU standard, 100 BU enhanced and 500 BU advanced, which covers eth_sendRawTransaction and trace and debug methods.

Limitations: the page names no rate limits or chain list, so it could not score well on coverage or throughput. Sending transactions costs 500 BU, an unusual place to meter.

How Do RPC Providers Price Their Plans?

RPC providers price by metered units, with free allowances, paid tiers and overage rates. Alchemy sells compute units pay-as-you-go. QuickNode, Chainstack and Infura sell tiered plans with included units and per-million overage. Ankr and Coinbase meter prepaid or usage credits at flat or tiered method rates. The method weight, not the headline price, drives the bill.

Three things change the real cost most. First, log queries: eth_getLogs ranges from 20 to 255 units depending on the vendor. Second, retries: a retry loop that hammers a rate-limited endpoint can double billable calls, which our guide to API retry logic in production covers. Third, archive and trace methods, which Chainstack bills at 2 RU and Infura bills at 1,000 credits for debug_traceTransaction.

Which RPC Provider Is the Cheapest?

On this request mix, Chainstack is cheapest at $2.45 per million calls when its Growth plan is fully used. Among the others, QuickNode's Business plan works out at $9.99, Infura's Team plan at $10.63, Alchemy at $15.39, Ankr at $20.00 and Coinbase CDP Node at $20.25. Prices are as of 18 November 2026.

Provider (plan)Units per callUnit priceCost per 1M callsFree calls a month
---------------
Chainstack Growth1 RU$49 / 20M RU = $2.45 per M$2.45 (overage $15.00)3,000,000
QuickNode Business20 credits$999 / 2,000M = $0.4995 per M$9.99 (Build: $12.25)500,000 (one-time trial)
Infura Team106.25 credits$225 / 2,250M = $0.10 per M$10.63 (Developer: $11.81)about 847,000 (table basis)
Alchemy Pay as You Go29.6 CU$0.52 per M$15.39about 1,013,000
Ankr Premium200 credits$0.10 per M$20.001,000,000
Coinbase CDP Node40.5 BU$0.50 per M$20.25about 247,000

Assumptions: 60% eth_call, 25% eth_getBalance and 15% eth_getLogs on recent blocks; 30-day months for Infura's daily quotas; plans fully used, which flatters tiered plans for low-volume users. At low volume, free tiers matter more: a small project may never pay anyone.

Alchemy vs QuickNode vs Infura: Which Should You Choose?

Choose Alchemy if you want usage billing with no plan to outgrow and 300 requests a second available at pay-as-you-go. Choose QuickNode if you want archive data included and clear tiers. Choose Infura if you are already in the MetaMask and Consensys tooling, and verify its free-tier limits first. On this mix Alchemy is $15.39 per million calls, QuickNode Build $12.25 and Infura Developer $11.81.

Their rankings are close enough that your method mix matters more than the logo. A log-heavy job favors QuickNode's flat 20 credits for eth_getLogs over Infura's 255. A balance-and-call job narrows the gap. For event-heavy analytics, a different tool may fit better, as our comparison of on-chain analytics platforms shows.

Which Should You Choose by Use Case?

Hobby or prototype: Chainstack's free plan gives about 3 million calls a month on this mix, but at 25 requests a second and without archive access. Alchemy's free plan allows 15 requests a second and covers about a million calls. If you are following a tutorial such as our Python web3 guide or the Web3 dApp walkthrough, any free tier will do.

Production dApp with predictable volume: Chainstack Growth or Pro, if flat per-call pricing suits your mix. Model the overage rate before you commit, because it is higher than the included rate.

Bursty traffic and no commitment: Alchemy pay-as-you-go, with 300 requests a second and no monthly floor.

Trace-heavy or archive-heavy work: QuickNode, where archive data is included on every plan and trace and debug starts at Build. Check that your methods are covered before committing.

Account abstraction and bundler workloads: look at which provider documents the bundler methods you need, as in our ERC-4337 developer guide. Private transaction routing to limit sandwich attacks is a separate question covered in the MEV explainer.

Cost-sensitive and ready to use Coinbase tooling: Coinbase CDP Node's 10 million free BU a month is attractive for light use, but confirm chain support and rate limits first, since the pricing page does not state them.

Also Considered, Not Scored

Four providers were fetched on 18 November 2026 and could not be scored, because their pricing could not be verified. Pricing is never filled in from memory or third-party pages.

  • dRPC (https://drpc.org/pricing): the page returned only its title, with no plan or price text, on both the earlier attempt and the retry today.
  • Dwellir (https://www.dwellir.com/pricing): the fetch failed with a decompression error, as it did in earlier attempts.
  • Blast API (https://www.blastapi.io/pricing): the server returned HTTP 403 Forbidden.
  • GetBlock (https://getblock.io/pricing/): the page loaded only partially. It showed one Pro plan at $399 a month billed annually, 800 requests a second and $0.40 per million compute units, but it did not state the included amount for the plan, the free tier's limits or per-method weights, so it could not be normalized.

Two more were loaded but excluded from scoring. OnFinality publishes plans, such as Growth at $49 a month for 20 million response units, but states no per-method unit weights, so no per-call cost can be derived. Tatum's page shows only a free tier of 100,000 lifetime credits and dedicated-key plans at $99 to $1,049 a month, with no cost per call. Helius is Solana-only and was not included in this Ethereum-mix comparison.

Contradictions Found on Vendors' Own Pages

  • Infura free tier: the pricing table says 3 million daily credits and 500 credits a second; the FAQ on the same page says 6 million and 2,000. Both are at https://www.infura.io/pricing.
  • Infura overage: the FAQ says paid plans can buy additional credits, but the table's extra credits row showed no values; only a $200 a month add-on for 55 million credits appeared.
  • Alchemy trace access: the feature table lists Trace API and Debug API with a dash, and the page does not say which plans include them.
  • Chainstack node types: the docs say debug and trace are 1 RU on full Trader Nodes but 2 RU on Global Nodes, and that Trader Nodes are deprecated on 1 December 2026, so the rate you pay depends on node type.
  • QuickNode eth_getLogs: search results surfaced older or third-party figures of 6 and 8 credits for eth_getLogs. QuickNode's Ethereum credits page, read today, lists 20, and that is what this guide uses.

What About Uptime and Latency Claims?

Every provider publishes uptime and latency claims, and every such claim is the vendor's own. Alchemy's Enterprise plan lists signed SLAs, and Ankr's Premium plan states up to roughly 1,500 requests a second per endpoint; both are vendor-stated. QuickNode runs a public status page, which reports incidents but is not an independent benchmark. If reliability matters for your decision, run your own test against your own methods and regions before signing a plan.

Conclusion

On documented pricing and the mix assumed here, Chainstack's flat request units give the lowest cost per million calls and the biggest free tier, Alchemy offers the simplest usage-based plan, and QuickNode includes archive data everywhere. Infura's contradictory pricing page and Coinbase's unstated limits cost them points. None of this is investment or financial advice; it is a pricing comparison. Change the request mix, and the order changes, so rerun the arithmetic with your own methods before choosing.

This is an editorial synthesis of documentation and published pricing, checked on 18 November 2026; see our [methodology](/methodology). Verify current details with each provider before you buy.

Sources

Key Takeaways

  • Four units are in play: Alchemy compute units, QuickNode API credits, Infura credits and Chainstack request units, so a price per million units says little until you multiply by the per-method weight.
  • On the stated mix, one call costs 29.6 Alchemy compute units, 20 QuickNode credits, 106.25 Infura credits, 1 Chainstack request unit, 200 Ankr credits and 40.5 Coinbase billing units.
  • The resulting cost per million calls runs from $2.45 (Chainstack Growth, full use) to $20.25 (Coinbase CDP Node), as of 18 November 2026.
  • eth_getLogs is the swing method: it costs 60 compute units on Alchemy, 255 credits on Infura, 20 credits on QuickNode and 100 billing units on Coinbase CDP Node.
  • Infura's pricing page contradicts itself on the free tier: its table says 3 million daily credits at 500 credits a second, while its FAQ says 6 million at 2,000.
  • Four providers were not scored because their pricing could not be read today: dRPC, Dwellir, Blast API and GetBlock.
  • Uptime and latency figures are vendor-stated, and no independent measurement was used in the scores.

Frequently Asked Questions

What is the best RPC provider for Ethereum?

It depends on your request mix. On documented pricing, Chainstack scored highest here at 92 out of 100, mainly on flat one-unit billing. Alchemy scored 67.5 for its throughput and simple pay-as-you-go rate. Rankings reflect cost, free tier, coverage, throughput and pricing transparency, not measured latency, which this guide did not test.

What is a compute unit in RPC pricing?

A compute unit, or CU, is Alchemy's billing unit. Each JSON-RPC method has a published weight reflecting how heavy it is: eth_call is 26 CU, eth_getBalance 20 and eth_getLogs 60. Other providers use their own units, such as credits or request units, so a price per million units cannot be compared across vendors.

Which RPC provider has the best free tier?

On the stated request mix, Chainstack's free Developer plan covers about 3 million calls a month, Alchemy and Ankr about 1 million each, Infura about 850,000, and Coinbase CDP Node about 247,000. QuickNode offers a one-month trial of 10 million credits rather than a recurring free plan.

Is Alchemy cheaper than Infura?

On this mix, yes. Alchemy works out at $15.39 per million calls on pay-as-you-go, while Infura's Developer plan works out at $11.81 only if you use its full daily allowance. Infura's eth_getLogs costs 255 credits against Alchemy's 60, so log-heavy workloads widen the gap in Alchemy's favor at scale.

Do RPC providers charge for failed requests?

Not always. QuickNode's pricing page says multipliers apply to valid 200-status responses. The other providers' pages fetched for this guide do not say how errors are billed, so test your own error rate in a free tier before assuming. Retry logic can multiply billable calls, so cap retries.

Can I use more than one RPC provider?

Yes, and many production apps do. A second provider as a fallback protects you from a single vendor's outage or rate limit. Most libraries accept a list of endpoints, and a retry policy that rotates providers keeps costs predictable. Check each plan's terms, since some free tiers restrict commercial use.

Reviewed by

Jordan Paul

CTO, Appear

Reviewed for technical accuracy on November 18, 2026

Jordan Paul is a chief technology officer and enterprise solutions architect who has built production blockchain, machine-learning and real-time tracking systems, with clients including Tesla, Medallia and Atlassian. He is CTO at Appear and at TZRO.ai, and previously served as CTO of Xucre Wallet, Smart Campaigns and REC Protocol. His listed top skills are smart contracts, Ethereum and blockchain, and he holds Salesforce architect certifications.