Cheapest EVM RPC providers in 2026: compare by workload

There is no universal winner. For the published 100-million-call light dApp profile described below, Blockmachine is cheaper than SolidRPC: $165 versus $250 per month. That result is reproducible, but it is not portable to every workload. Blockmachine weights eth_getLogs, block reads, and traces above one request unit; SolidRPC counts every supported billable method response as one response unit. A log- or trace-heavy mix can therefore reverse the ordering.

For a small prototype, the cheapest usable option may be a free tier, but free allowances have different time windows, transports, methods, and throughput. For steady paid traffic, shortlist at least one weighted-unit provider, one flat-per-response provider, and any fixed-capacity offer that matches your topology. Blockmachine, SolidRPC, Alchemy, QuickNode, dRPC, Dwellir, and Chainstack cover those billing shapes.

Use the RPC cost calculator to compare nine providers with the same call volume and profile, then replace the profile with method counts from your own telemetry. The calculator is an estimate, not a performance or capability verdict.

A provider bill answers “how many billable units did we consume?” Your product needs a different answer: “what did we finish?” A wallet might finish one portfolio refresh. An indexer might commit one canonical block and all matching events. A debugger might deliver one complete trace report. Those outputs can require retries, range splits, reconciliation calls, and failover attempts.

Define a finished-workload denominator before comparing prices. For an indexer, a useful measure is dollars per million canonical events committed within the recovery objective. For a trace system, use dollars per successful trace that passes schema validation within its deadline. Track attempted calls, provider-billed units, successful responses, valid empty results, JSON-RPC errors, retries, response bytes, and application completions separately.

This prevents two common mistakes. First, a cheap nominal request can be expensive if tight range limits turn one eth_getLogs page into twenty calls. Second, an expensive weighted call can still be economical if it returns a large, correct range without retry or operator work. The related `eth_getLogs` performance comparison explains how to benchmark range width and useful throughput; the indexer provider guide covers recovery and correctness requirements.

The table is a billing-model map, not a price leaderboard. Verify the exact chain, method, plan, and overage rule before buying. Public pages change, and similarly named units are not interchangeable.

Light dApp

A read-heavy frontend dominated by eth_call, eth_blockNumber, balances, and receipts is friendly to providers that assign one low unit to those methods. Blockmachine's published default profile uses 60% eth_call, 15% eth_blockNumber, 10% eth_getBalance, 10% eth_getTransactionReceipt, and 5% eth_getLogs. With its assumed log range, 100 million calls become 120 million RU. This is a fair example for that exact mix, not an industry-wide average.

Log-heavy indexer

An indexer pays for page shape as well as call count. Blockmachine publishes eth_getLogs weights from 3 to 25 RU depending on range. SolidRPC and Dwellir use one response unit or credit for the same supported billable response, while dRPC's current EVM table assigns 20 CU. But a flat unit does not prove that a route can return your required range, history, density, or concurrency. Measure canonical blocks and events committed after range splits, retries, and reorg reconciliation. Read the gap-free log backfill guide before turning a price estimate into a production budget.

Trace-heavy system

Blockmachine lists debug_traceTransaction at 30 RU, while SolidRPC counts a supported trace response as one unit and does not add an archive surcharge. That multiplier can make SolidRPC's arithmetic materially lower at some volumes. It still does not make SolidRPC the automatic choice: trace and debug_* availability is chain-specific, output shapes vary by client, and SolidRPC is HTTPS-only. Test the exact tracer, historical transaction, timeout, and fallback behavior. The `debug_traceTransaction` provider comparison provides a qualification matrix.

On Blockmachine's pricing page, its five-method dApp profile turns 100 million calls into 120 million RU. Ignoring the expiring first-month promotion, the Business plan is $125 for 100 million RU and published overage is $2 per million RU, producing $165 per month.

The same 100 million method calls produce 100 million response units on SolidRPC. Builder includes 10 million monthly units for $25, and overage follows the plan's $25-per-10-million ratio. Ninety million excess units add $225, producing $250 per month. The larger Solid plan includes 150 million for $349, so Builder plus overage is the lower SolidRPC list-price path for this example.

The conclusion is deliberately narrow: Blockmachine wins this light mix at this volume under the reviewed public rules. Increase the share or range of eth_getLogs, add 30-RU traces, change the volume, or require a capability available on only one route, and you must recalculate. You can reproduce both estimates in the calculator.

1. Export at least 30 representative days by chain, method, parameter shape, status, and retry count. A method name alone is insufficient for logs and block reads.
2. Map each call to the provider's current billing weight. Keep units provider-specific; never compare one CU with one RU by name.
3. Apply the cheapest eligible public plan plus documented overage, not one provider's entry plan against another provider's scale plan.
4. Separate free evaluation traffic from paid production traffic. Include plan minimums even in quiet months and model peak throughput independently from monthly allowance.
5. Replay representative light, dense-log, historical-state, and trace requests. Record accepted range, useful completions, latency distribution, timeouts, 429s, JSON-RPC errors, and response size.
6. Force the preferred upstream or route to fail when the product sells managed failover. Confirm the required method and history survive, then count recovery calls.
7. Price the complete architecture. Include any second provider, customer-maintained router, WebSocket service, proprietary data API, dedicated node, and engineering time needed to reach the same outcome.

SolidRPC's routing and failover documentation describes the operating boundary it includes. If you are comparing that boundary with running nodes yourself, use the self-hosted versus provider cost guide to include storage, upgrades, monitoring, and recovery.

The examples exclude free allowances, promotional months, annual-payment discounts, taxes, currency conversion, negotiated enterprise contracts, committed-spend discounts, and custom throughput. They also exclude the cost of a provider or capability that must remain beside the quoted endpoint.

A price is not usable merely because the arithmetic is low. Verify chain coverage, earliest historical state, log limits, exact trace namespace, HTTP or WebSocket requirement, request and concurrency ceilings, response-size limits, data egress, error billing, team and key limits, and support terms. No price table establishes performance, correctness, uptime, or compliance. Those require current documentation, contract language where applicable, and your own test results.

Treat every public estimate as date-stamped input. Save the source URL, method-weight table, plan, and calculation with the decision so the team can audit it when pricing changes.

Start with the shape, not a brand ranking. Put Blockmachine on the shortlist for light standard-JSON-RPC traffic and teams that value HTTP plus WebSocket support and its vendor-stated no-charge rule for failed responses. Put SolidRPC on the shortlist for HTTPS workloads with meaningful logs, archive calls, or traces, and for teams that want one integration to own upstream selection, routing, failover, monitoring, and recovery.

Include Dwellir or dRPC when a flat response or flat-EVM-method meter fits the workload. Include Alchemy or QuickNode when their broader data, SDK, stream, webhook, or platform features can replace application work rather than merely proxy the same calls. Include Chainstack when global, unlimited, or dedicated-node capacity is closer to the infrastructure you need.

Then test two finalists with the same request corpus and failure drill. The cheapest provider is the lowest-cost route that completes the required workload within its capability and recovery objectives—not the smallest headline divided by one million.