A DeFi backend running a price oracle does 100 million eth_call requests per month. Same workload, same method, same response payload. The bill ranges from $196 to $2,000 depending on which RPC provider is on the invoice. That is a 10x spread for the most-used JSON-RPC method in EVM development, and the variance is almost entirely driven by pricing models that the provider's homepage does not put front and center.
This post walks through the actual numbers. The benchmark below uses publicly disclosed pricing from 16 major EVM RPC providers as of April 2026, normalized to a single metric (effective cost per million eth_call) and ranked. The headline rates that providers advertise (cost per compute unit, total units included, plan price) are not the numbers that determine your monthly bill. The number that matters is what you pay per call after the compute unit weight is applied.
If you run anything read-heavy on EVM (DeFi reads, allowance checks, contract simulations, dApp UIs), this is the benchmark to model against.
Why eth_call Is the Right Benchmark
eth_call executes a read-only contract call against the current state without broadcasting a transaction. It returns the result of a view or pure function. Every DeFi frontend uses it to fetch reserves, balances, prices, allowances, and oracle data. Every contract simulator uses it to test execution paths. Every wallet uses it before submitting a transaction to verify the call will succeed.
For most production EVM workloads, eth_call accounts for the majority of total RPC traffic. A typical DEX aggregator UI fires dozens of eth_call requests on every page load (token balances, allowances, expected output amounts, slippage checks). A liquidation bot polls eth_call thousands of times per minute monitoring health factors. An indexer enriching events with current state issues an eth_call per token contract per block.
That is why benchmarking on eth_call is the most honest way to compare provider pricing. Benchmarking on eth_getBalance or eth_blockNumber flatters compute-unit providers because those methods carry low CU weights. Benchmarking on debug_traceTransaction favors flat-rate providers because trace methods carry the highest CU weights. eth_call sits in the middle of the weight curve and dominates real-world workloads, so it is the closest thing to a fair single-method benchmark.
How Providers Price eth_call
Two pricing models cover most of the market.
Request-based pricing. One API response equals one billable request. An eth_call costs the same as an eth_getBalance costs the same as a debug_traceTransaction. Dwellir and Chainstack use this model. Your monthly bill is straightforward to model: total requests divided by plan capacity, then overage rates apply above the included tier.
Compute unit (CU) pricing. Each method gets a CU weight. The provider charges per million CU consumed, not per million requests. An eth_call might cost 20 CU, 26 CU, 30 CU, 75 CU, 80 CU, or 200 CU depending on the provider. The headline rate (for example "$0.10 per million CU") looks aggressive on a pricing page, but the effective cost per request is the headline rate multiplied by the CU weight.
The CU weight is where the pricing gap opens. Two examples make it concrete.
Ankr charges $0.10 per million CU and assigns 200 CU to each EVM eth_call. Effective cost per million eth_call: 200 x $0.10 = $20.00. The headline "$0.10 per million" looks like a steal until you trace through the multiplier.
Dwellir charges $1.96 per million requests on the Developer plan, with eth_call counted as one request. Effective cost per million eth_call: $1.96. There is no multiplier to discover later.
This is not a critique of compute-unit pricing as a model. CU weights exist for a reason. A debug_traceTransaction is genuinely more expensive for the provider to serve than an eth_blockNumber, and CU weights let providers price for that. The problem is that the weights are buried in documentation rather than featured in pricing, so the headline numbers create a false sense of comparability between providers using different models.
The Data: eth_call Pricing Across Providers
The table below shows the cheapest effective eth_call rate available from each of the 16 providers in the benchmark. The rightmost column is the multiplier against Dwellir's $1.96 per million. Pricing is from publicly disclosed plans as of April 2026.
| Provider | Cheapest plan | $/M eth_call | 100M eth_call | vs Dwellir |
|---|---|---|---|---|
| Dwellir | Developer ($49/mo) | $1.96 | $196 | 1.00x |
| Chainstack | Growth ($49/mo) | $2.45 | $245 | 1.25x |
| OnFinality | Growth ($49/mo) | $2.45 | $245 | 1.25x |
| Uniblock | Growth ($49/mo) | $2.94 | $294 | 1.50x |
| Spectrum | Enterprise ($459/mo) | $3.06 | $306 | 1.56x |
| Conduit | Pro ($50/mo) | $3.75 | $375 | 1.91x |
| Nodies | Pro ($200/mo) | $4.00 | $400 | 2.04x |
| Tenderly | Starter ($50/mo) | $5.71 | $571 | 2.91x |
| dRPC | PAYG ($299/mo) | $5.98 | $598 | 3.05x |
| Infura | Team ($225/mo) | $8.00 | $800 | 4.08x |
| Alchemy | PAYG ($2,000/mo) | $8.00 | $800 | 4.08x |
| GetBlock | Pro ($499/mo) | $8.32 | $832 | 4.24x |
| AllThatNode | Scale ($139/mo) | $9.27 | $927 | 4.73x |
| QuickNode | Business ($999/mo) | $9.99 | $999 | 5.10x |
| Validation Cloud | PAYG ($350/mo) | $14.00 | $1,400 | 7.14x |
| Ankr | PAYG (any tier) | $20.00 | $2,000 | 10.20x |
The numbers in the rightmost column are the cost of running your eth_call workload on each provider relative to Dwellir. These are best-case rates: every entry shows the cheapest plan that provider offers, not the most expensive. The spread is still 10x.
Nine of the fifteen alternatives charge at least 3x what Dwellir charges per eth_call. Six charge at least 4x. Three charge 5x or more. The most expensive (Ankr) costs 10.2x more per call than the cheapest in the comparable set.
The mechanism is the compute-unit multiplier explained earlier. Headline cost-per-CU rates look broadly comparable across providers, but the CU weight assigned to eth_call swings from 1 (Dwellir, Chainstack, OnFinality) to 200 (Ankr). That weight is what determines your bill, and it lives in documentation, not on the pricing page.
What This Means for Your Monthly Bill
The 10x per-call spread translates directly into monthly cost at any volume. The table below applies the cheapest and most expensive effective eth_call rates from the main benchmark to three representative workload sizes.
| Monthly volume | Workload profile | Cheapest in set | Most expensive in set | Monthly gap |
|---|---|---|---|---|
10M eth_call | Small dApp, indexer, or hobby project | ~$20 | ~$200 | $180 |
100M eth_call | Production DeFi backend, mid-size dApp | ~$196 | ~$2,000 | $1,804 |
1B eth_call | High-volume protocol, aggregator, infra provider | ~$2,000 | ~$20,000 | $18,000 |
These figures multiply volume by the cheapest and most expensive effective rates per eth_call from the main table. Actual plan prices step up at fixed tiers, so the realistic monthly bill a team lands on is usually slightly above the per-call calculation - either through overage charges or by stepping into the next plan. Even with that caveat, a team running 100M eth_call per month is looking at roughly $2,400 per year at the low end and $24,000 per year at the high end. Over three years, the gap on a single method on a single chain compounds past $60,000.
The dollar gap grows linearly with volume because cost-per-call is the variable that compounds. Picking a pricing model that treats an eth_call as one billable request - rather than 26, 80, or 200 compute units - is the lever that changes those numbers.
How to Evaluate Your Own Workload
Headline pricing is not the number to compare. Effective per-method pricing is. Modeling your own bill takes four steps.
1. Sample your method mix. Pull a week of RPC logs from your existing endpoint. Count requests by method name. For most read-heavy EVM workloads, eth_call is 40-70% of total volume, with eth_getBalance, eth_getLogs, eth_blockNumber, and eth_getTransactionReceipt covering most of the rest.
2. Look up CU weights per provider. Every CU-based provider publishes a method weight table somewhere in their docs. Find it. The weight on eth_call, eth_getLogs, and any trace methods you use are the ones that determine your bill. A debug_traceTransaction at 75-400 CU dwarfs everything else if you call it regularly.
3. Multiply weights by your volume per method. For each provider, sum (request volume per method x CU weight per method) and divide by 1,000,000 to get total CU consumed. Then multiply by the cost per million CU to get the bill. For request-based providers, the calculation is simpler: total requests divided by plan capacity, with overage rates applied above the cap.
4. Add overage costs. Most plans have a hard cap at the included allocation, with overage rates above that. Some plans throttle instead of charging. Build the calculation against your actual peak month, not your average month, because the overage line is where bills go off the rails.
The output of this exercise is one number per provider: total monthly cost for your specific workload. That is the only number worth comparing.
Where the Cheapest Plans Land
Looking back at the table, the plans under $3 per million eth_call are concentrated among providers using request-based pricing or 1-CU eth_call weights. Dwellir's three paid tiers occupy the cheapest positions in the comparable set at $1.96 to $2.00 per million. Chainstack's and OnFinality's plans cluster around $2.45 to $2.50.
The reason is structural rather than promotional. When eth_call is billed 1:1 against your plan capacity, the price you see on the pricing page is the price you pay per call. There is no method weight to look up, and no multiplier surprises you when you read your invoice. For workloads where eth_call is the dominant method (which describes most production EVM applications), 1:1 pricing produces both the lowest effective cost and the most predictable monthly bill.
This is a benchmark for eth_call only. Trace methods, archive queries, and eth_getLogs over wide block ranges would shift the picture. A workload that is 40% debug_traceTransaction will tilt the numbers differently than a workload that is 90% eth_call. The honest way to compare providers is to model against your own method mix, not against any single benchmark.
Run Your Own Numbers
The pricing pages of every provider in this table are public. The CU weights are published in their respective docs. A two-hour spreadsheet exercise against your own method mix will produce a number per provider that is more reliable than any headline rate or marketing claim, including this one.
For teams running read-heavy EVM workloads where eth_call dominates, Dwellir's pricing page and API documentation are a good place to start the comparison. To discuss specific workloads or model a custom plan, contact the Dwellir team.
For broader context on RPC pricing across providers and chains, see Best RPC Node Providers of 2026.
