A "$0.40 per million CU" headline and a "$0.10 per million credits" headline are not the same price. One provider's unit might cost 3–12x more per call than another's for the exact same method — the unit itself is the variable, not just the rate. This tool converts your real call mix into each provider's own weighting, then prices it against their actual plan tiers.
Cost at your call mix — cheapest first
Each provider's own compute-unit/credit weights applied to your mix, then priced against their real plan tiers (free tier, flat monthly plan, or pay-as-you-go — whichever is cheapest for that provider at this volume).
| Provider | Billing unit used | Plan / tier that fits | $/mo | $ per 1,000 actual calls |
|---|
Why the same call costs a different number of units on every provider
Published per-method weight for each provider's own compute-unit/credit system. These are fixed reference numbers, not affected by your inputs above.
| Method category | Alchemy (CU) | Infura (credits) | QuickNode (credits) | Ankr (credits) |
|---|
| Simple read (eth_call / eth_getBalance) | 26 | 80 | 20 | 200 |
| eth_getLogs | 60 | 255 | 75 | 200 |
| debug_traceTransaction / trace_call | 40 | 1,000 | 40 | 200* |
*Ankr's Node API doesn't weight standard EVM JSON-RPC methods by complexity — every method on the HTTPS Node API costs the same 200 credits, including debug/trace, which are Premium-tier only (not included in the free Freemium allowance regardless of credit balance).
⚠️ Estimate built from each provider's own published compute-unit/credit weight tables and plan pricing pages, verified 2026-08-12 — not a live billing feed. Providers revise weights, plan pricing and free-tier size without much notice (Infura moved to credits in January 2026; QuickNode has revised its credit multipliers more than once). Confirm current numbers on each provider's own pricing/docs pages before committing budget. ·
Report outdated price →
"$/CU" is not a price — it's half of one
Every RPC provider publishes a rate for its own accounting unit: Alchemy's compute unit (CU), Infura's and QuickNode's credit, Ankr's API credit. Comparing those headline rates directly — "$0.40 per 1M CU" vs "$0.10 per 1M credits" — tells you nothing, because the unit itself isn't standardized. Alchemy charges 26 CU for an eth_call; Infura charges 80 credits for the identical call; QuickNode charges 20. A price-per-unit comparison without a units-per-call comparison is comparing currencies without an exchange rate. The only number that means anything is the dollar cost of the calls you actually make — which requires multiplying your real method mix by each provider's real per-method weight, the calculation above does for you.
The CU-weighting mismatch, quantified
The gap isn't small. eth_getLogs — the method every indexer, wallet-history feature and event-driven backend depends on — costs roughly 3–4x more in Infura's credit system than in Alchemy's or QuickNode's. debug_traceTransaction, used by MEV searchers, simulation tools and forensic/compliance tooling, costs 1,000 credits on Infura versus 40 CU on Alchemy and 40 credits on QuickNode — a 25x gap on a single method. Ankr sidesteps the weighting question entirely on its standard Node API: every method costs the same flat 200 credits, which makes it comparatively expensive for read-heavy simple-call workloads but comparatively cheap for trace-heavy ones, since it never charges the 1,000-credit archive premium the weighted providers do. None of this shows up in a sticker-price comparison — it only shows up once you run your own call mix through each provider's actual weight table.
What this means for picking a provider
If your app is dominated by simple reads — balance checks, nonce lookups, basic eth_call — the provider ranking is close to what the sticker prices suggest. If your app leans on eth_getLogs for event indexing, or runs debug_traceTransaction/trace_call at any real volume, the ranking can flip entirely, and picking by sticker price alone can mean paying several times more than necessary for the exact same workload. Re-run the calculator with your real method breakdown — pulled from your own request logs, not a guess — before signing an annual RPC contract. Note this bill is separate from what your transactions cost to execute on-chain: RPC/node cost pays for reading chain state and broadcasting transactions, while on-chain gas (the L2 gas cost comparison calculator) is what you pay the network itself once a transaction lands. For the AI-agent-side payment rail cost, see the x402 micropayment fee calculator; for general API infrastructure billing, see the API gateway cost calculator.
Sources: Alchemy compute-unit cost docs and pricing; Infura/MetaMask credit-cost docs and pricing; QuickNode pricing and per-provider method-weight comparison; Ankr service plans and credit pricing docs.
L2 Gas Cost Comparisonx402 Micropayment FeeAPI Gateway CostFree Tier Runway
How this calculator works
The RPC Node Provider Cost Calculator takes your monthly call volume split into three categories — simple reads, log/event queries, and heavy/trace calls — and multiplies each by Alchemy, Infura, QuickNode and Ankr's own published compute-unit or credit weight for that category. The result is a total unit count per provider, which is then priced against that provider's real plan structure: whichever of its free tier, flat monthly plan, or pay-as-you-go rate is cheapest at that volume.
The output includes a $ per 1,000 actual calls column specifically so you can compare providers on a normalized basis regardless of how each one weights or bills — that number, not the sticker $/CU rate, is the one that actually predicts your bill. Run it once with your real logged method mix (not a guess) before signing an annual RPC contract, since the ranking genuinely changes based on how much of your traffic is eth_getLogs or trace calls versus simple reads.
Frequently asked questions
Why does the same 1 million RPC calls cost different amounts on different providers?
Every RPC provider invented its own internal accounting unit — Alchemy calls it a compute unit (CU), Infura and QuickNode call it a credit — and each assigns a different weight to the same JSON-RPC method based on how expensive that method is to serve on its own infrastructure. A simple eth_call costs 26 CU on Alchemy but 80 credits on Infura and 20 credits on QuickNode; eth_getLogs costs 60 CU on Alchemy, 255 credits on Infura, and 75 credits on QuickNode; debug_traceTransaction costs 40 on Alchemy and QuickNode but 1,000 credits on Infura — a 25x gap on that one method alone. A million identical calls therefore consume wildly different totals of each provider's billing unit, and since the $-per-unit rate also differs, the two effects compound into a real dollar spread that has nothing to do with which provider is "better," only which one happens to weight your specific call mix more cheaply.
What is a compute unit or API credit, and why can't I compare $/CU across providers directly?
A compute unit or credit is not a standardized measure of work — it is a provider-specific accounting number calibrated to that provider's own infrastructure costs, with no shared definition across companies. One Alchemy CU is not the same amount of server work as one Infura credit or one QuickNode credit, so a headline rate like "$0.40 per 1M CU" cannot be compared to "$0.10 per 1M credits" without first knowing how many units each provider charges for the specific methods you actually call. The only valid comparison is to convert your real call mix into each provider's own unit using their published per-method weight table, then price that out under their actual plan structure — which is what this calculator does instead of comparing sticker rates.
Which RPC provider is cheapest depends on my call mix — how much does that change the answer?
Substantially. An app that only does simple reads (balance checks, eth_call) tends to favor QuickNode's or Alchemy's lower per-call weights on those methods. An app that leans heavily on eth_getLogs for event indexing gets hit hardest on Infura, where that one method is roughly 3–4x more expensive in credits than the equivalent call on Alchemy or QuickNode. An app that runs debug_traceTransaction or trace_call frequently — MEV bots, forensic tooling, simulation backends — should treat Infura's 1,000-credit weight on that method as close to disqualifying at volume, while Ankr's flat per-call credit rate (it does not weight standard EVM methods differently by complexity) can flip from priciest to cheapest specifically because it doesn't punish heavy methods the way weighted providers do. There is no universally cheapest provider — only a cheapest provider for your specific method mix, which is the entire reason to run your own numbers instead of trusting a provider's own marketing comparison.
Is this calculator using live provider pricing?
No — it uses each provider's own published compute-unit or credit weight per method and their published plan pricing, verified against Alchemy, Infura/MetaMask, QuickNode and Ankr's own documentation as of 2026-08-12. Providers change these weights and prices without much notice — Infura moved to a credit model in January 2026 and QuickNode has revised its multiplier buckets more than once — so treat this as a structural comparison of how the billing models behave, confirm current numbers on each provider's own pricing/docs pages before committing to a plan, and use the report-outdated-price link below if you spot a stale figure.