Skip to content
New guideAgent Cookbook 12 copy-ready prompts for AI coding agents.See recipes
All blog posts
Best Ethereum RPC Providers 2026: Cost per Million Compared

Best Ethereum RPC Providers 2026: Cost per Million Compared

By Elias FaltinUpdated 39 min read

Ethereum remains the gravity well of decentralized finance. Over $55.6 billion in TVL (DeFiLlama, April 2026), 2–3.6 million daily transactions, and 800,000+ validators securing the network make it the blockchain that institutional capital, protocol teams, and application developers build on first. That role deepened after the Dencun upgrade brought EIP-4844 blob transactions, cutting L2 data posting costs by 10-100x and accelerating an L2 ecosystem that now holds $40.5 billion in Total Value Secured across L2s (L2Beat).

Dwellir's Ethereum RPC endpoint page lists the HTTPS and WebSocket URLs, supported methods and pricing.

That scale creates a concrete infrastructure problem. Public Ethereum endpoints cap you at roughly 100 requests per minute. A DeFi aggregator polling prices across 20 pools, a wallet tracking real-time token balances, or an indexer processing eth_getLogs across thousands of blocks will exhaust that limit in seconds. Then there is MEV exposure, with over $1.8 billion extracted from on-chain transactions to date. At that point, the difference between a commodity RPC endpoint and a production-grade one becomes a security question, not just a performance one.

This comparison covers 8 Ethereum RPC providers across pricing, features, MEV protection, and production considerations. Prices are a list-price snapshot from 2026-10-07, normalized to dollars per million calls.

What to Look for in an Ethereum RPC Provider

Ethereum's architecture and ecosystem create specific requirements that differ from newer chains. Here is what matters most when evaluating providers.

MEV Protection: Front-running and sandwich attacks remain an active threat on Ethereum L1. If your application submits swaps, liquidations, or any value-bearing transactions, MEV protection through private mempools or Flashbots integration is not optional. It is a security requirement. Over $1.8 billion has been extracted from unprotected transactions.

Archive Node Access: Ethereum's 10-year history makes archive data essential for analytics platforms, block explorers, portfolio trackers, and any application that queries historical state. Not all providers include archive access at every tier, and those that do often charge premium compute units for archive queries.

WebSocket Support: DeFi applications, trading bots, and event-driven architectures depend on real-time data through WebSocket subscriptions. Polling via HTTP introduces latency that compounds across high-frequency workloads. Reliable WSS endpoints with stable connections are critical for production Ethereum applications.

Pricing Model Clarity: Most providers advertise pricing in "compute units" or "credits," but these units are not standardized. A single eth_call costs 1 unit on Dwellir, 20 on QuickNode, 26 on Alchemy, 80 on Infura, and 200 on Ankr. A provider advertising $0.10 per million compute units can actually cost $20 per million API calls once you account for the multiplier. The only reliable way to compare pricing is to normalize to cost per actual API call. See the true cost comparison below, and the eth_call pricing benchmark for the same math across 16 providers.

Multi-Chain Compatibility: Most Ethereum teams also deploy on L2s or maintain cross-chain infrastructure. A provider that covers Ethereum mainnet, Arbitrum, Base, and Optimism under a single API key and billing account reduces operational overhead significantly.


The numbers: price, credits, free tier, archive, WSS and RPS

Entry-tier cost per million eth_call requests, cost per million on the house mix described in the methodology, the unit each provider bills in, and the highest rate limit you can buy without a sales call. Archive and WSS refer to Ethereum mainnet on standard shared plans. Sorted by eth_call cost.

Bar chart of cost per million eth_call requests on entry-tier plans: Dwellir $1.96, Chainstack $2.45, dRPC (Pro) $4.80, Infura $8.89, GetBlock $10.89, QuickNode $12.25, Alchemy $13.65, Ankr $20.00.
ProviderCost per 1M eth_call (entry plan)Cost per 1M on house mixCredits modelFree tierArchiveWSSRPS cap (top self-serve plan)
Dwellir$1.96 ($49, 25M responses)$1.961 credit per response, every method100K responses/day, 20 RPSYesYes5,000, bursts to 10,000 ($999)
Chainstack$2.45 ($49, 20M request units)$2.451 request unit per call, archive and debug 23M request units/month, 25 RPSYes (2 units)Yes600 ($499)
dRPC$4.80 ($49 Pro, ~10M requests)$4.8020 CU per method, $6 per 1M requests on overage and pay as you go210M CU/month (~10.5M requests), 100 RPSYesYes600 ($199)
Infura$8.89 ($50, 15M credits/day)$10.83Credits, 80 per eth_call, 255 per eth_getLogs3M credits/day (~30,800 calls)YesYes~410 calls/s on the mix, 40,000 credits/s ($225)
GetBlock$10.89 ($49, 90M CU)$10.89CU, 20 per call, archive and debug 2x50K CU/day (2,500 calls), 20 RPSYes (2x CU)Yes800 ($499)
QuickNode$12.25 ($49, 80M credits)$12.25API credits, 20 per call, debug and trace 2x10M credits, 15 RPS, 1-month trialYesYes500 ($999)
Alchemy$13.65 (pay as you go)$13.60CU, 26 per eth_call, $0.525 per 1M CU30M CU/month (~1.16M calls)YesYes300 req/s included; 30,000 CU/s (~1,150 eth_call/s) for $640 more per month
Ankr$20.00 (pay as you go)$20.00Credits, 200 per call, $0.10 per 1M credits200M credits/month (~1M calls), keyless public endpointYesPremium onlyAbout 1,500 per endpoint

Dwellir's Free plan excludes eth_getLogs; paid plans allow a 500-block range on Developer and 10,000 blocks on Growth and Scale. The RPS column is the ceiling of the highest shared plan with a published price, so QuickNode's 500 costs $999 while Chainstack's 600 costs $499. Infura's two cost columns differ because eth_getLogs costs 255 credits there, against 80 for eth_call.

Top pick by use case

Short answers, from list prices and published limits checked on 2026-10-07. The numbers table and the methodology show the working.

  • Lowest cost per request on a metered plan: Dwellir, $1.96 per million calls on the $49 Developer plan. One credit per response for every method, including trace and debug.
  • Per-request pricing with SOC 2 Type II and ISO 27001: Chainstack, $2.45 per million on the $49 Growth plan, with archive and debug at 2 request units.
  • Flat rate for steady high volume on one chain: GetBlock Limitless full node, $500 a month for 150 RPS, about $1.28 per million at full use but without archive. Dwellir Unlimited Nodes start at $119 for 25 RPS, $1.83 per million at full use.
  • Highest published shared rate limit: Dwellir Scale, 5,000 responses per second with bursts to 10,000, at $999 per month. dRPC's highest self-serve plan, Scale at $199, allows 600 RPS.
  • MEV-protected transaction submission: dRPC or Infura, both route transactions through private channels. Pair either with a cheaper provider for reads.
  • Free tier for prototyping: dRPC (210M compute units a month, roughly 10.5 million requests). Dwellir's Free plan allows 100,000 responses a day at 20 RPS, and Alchemy's 30M compute units cover roughly 1.16 million calls.
  • Trace-heavy indexing: Dwellir. debug_traceTransaction costs $1.96 per million, against $4.80 on dRPC Pro, $4.90 on Chainstack, $21.00 on Alchemy, $21.78 on GetBlock and $111.11 on Infura.

1. Dwellir - Transparent 1:1 Pricing Across All Methods

Dwellir

Dwellir provides Ethereum mainnet access with full archive node support and a pricing model built around simplicity: every RPC response costs 1 credit regardless of method complexity. Whether you call eth_chainId or run debug_traceTransaction, the cost is identical. This eliminates the compute unit math that makes budgeting unpredictable on Ethereum, where DeFi workloads routinely mix lightweight balance checks with heavy trace and log queries.

Dwellir supports both HTTPS and WebSocket (WSS) endpoints for Ethereum, with trace and debug APIs included in all paid plans at no extra cost, and an Erigon endpoint alongside the standard one. The same API key works across 150+ networks, making it straightforward for teams that operate across Ethereum L1 and its L2 ecosystem. See the Ethereum network page for endpoints.

Key Features

  • 1:1 Credit System: Every method (standard, trace, debug, archive) costs 1 credit. No compute unit multipliers.
  • Archive Node Access: Full historical Ethereum state available on all endpoints.
  • Protocol Support: HTTPS and WebSocket (WSS) for real-time event subscriptions.
  • 150+ Network Coverage: Single API key spans Ethereum, Arbitrum, Base, Optimism, and 140+ more networks.
  • Burst Protection: Sustained RPS from 20 to 5,000 with burst capacity up to 10,000 RPS.
  • Trace and Debug APIs: debug_traceTransaction, trace_replayTransaction, and related methods included at no premium.
  • Crypto Payments: Pay in crypto on every paid plan, from Developer to Enterprise.

Pricing Structure

PlanMonthly CostResponses IncludedRPS (Burst)Effective $/1M CallsOverage $/1M Calls
Free$0100,000/day20$0-
Developer$4925M100 (500)$1.96$5.00
Growth$299150M500 (2,500)$1.99$3.00
Scale$999500M5,000 (10,000)$2.00$2.00
Unlimited NodeMonthly CostCalls Covered at Full RPSEffective $/1M Calls
25 RPS$11965M$1.83
100 RPS$479260M$1.84
250 RPS$1,199650M$1.84
500 RPS$2,3991.3B$1.85
1,000 RPS$4,7992.6B$1.85

Teams that outgrow shared plans have two routes. Unlimited Nodes are single endpoints with the meter switched off, sold by RPS. A dedicated Ethereum node cluster lists at $12,600 per month, with no rate limit and no request counting. Sign up for the Free plan to test before paying.

Pros and Cons

Advantages:

  • Predictable billing regardless of method mix. No compute unit calculations needed.
  • Trace and debug endpoints included at no premium on all paid plans.
  • Multi-chain footprint for unified Ethereum L1 + L2 infrastructure across 150+ networks.
  • Direct engineering support on Growth plans and above.
  • Burst protection up to 10,000 RPS handles traffic spikes without dropped requests.

Considerations:

  • No built-in MEV protection. Teams handling MEV-sensitive transactions need a complementary solution such as dRPC or Infura.
  • Enhanced APIs (NFT indexing, token metadata) less extensive than larger platform providers.
  • No SOC 2 report. Teams that need one should look at Chainstack, GetBlock or QuickNode.
  • Not the cheapest flat-rate option at high, steady volume: GetBlock's Limitless full node works out lower at 150 RPS and above, though without archive.

Best For

DeFi protocols, analytics platforms, and multi-chain teams that need cost-predictable Ethereum infrastructure with full archive access and advanced debugging capabilities. The 1:1 pricing model is particularly valuable for workloads with heavy trace and log queries where compute unit pricing creates budget uncertainty.


2. Chainstack - Per-Request Pricing with SOC 2 Compliance

Chainstack

Chainstack is the closest alternative to Dwellir on pricing model: one request unit per call on recent state, so a bill tracks call count rather than method weights. Archive reads (127 or more blocks behind the tip) and every debug or trace call cost 2 request units. On top of that it adds what most providers do not offer: SOC 2 Type II and ISO 27001 documentation for regulated teams.

The platform spans shared Global Nodes, dedicated nodes, and an Unlimited Node add-on that removes per-request billing. It deploys across AWS, GCP, and Azure with geo-balanced routing, and handles node maintenance, upgrades, and monitoring for teams without dedicated protocol DevOps.

Key Features

  • Request-Unit Billing: 1 RU per call, 2 RU for archive reads and debug or trace.
  • SOC 2 Type II and ISO 27001: Audit documentation for regulated environments.
  • Multi-Cloud Deployment: AWS, GCP, and Azure options with geo-balanced routing.
  • Unlimited Node Add-on: Flat monthly fee for unmetered requests within chosen RPS tiers.
  • Team Collaboration: Role-based access and per-project API keys.

Pricing Structure

PlanMonthly CostRequest UnitsRPSEffective $/1M CallsOverage $/1M Calls
Developer$03M25$0$20.00
Growth$4920M250$2.45$15.00
Pro$19980M400$2.49$12.50
Business$499200M600$2.50$10.00
Enterprise$990400MUnlimited$2.48$5.00

Annual billing lowers Growth to $40, Pro to $166, Business to $416 and Enterprise to $825 per month. The Unlimited Node add-on requires Growth or above and starts at $149 for 25 RPS; with the $49 Growth base that is $198, or $3.05 per million at full use, so Growth stays the better rate per call. Prices for the higher Unlimited Node tiers were not visible on the live pricing page on 2026-10-07.

Pros and Cons

Advantages:

  • Near-flat per-request pricing, second only to Dwellir on cost per call.
  • SOC 2 Type II and ISO 27001 documentation for regulated and institutional teams.
  • Archive, debug and trace on Growth and above.
  • Multi-cloud deployment reduces vendor lock-in at the infrastructure layer.

Considerations:

  • Archive reads and debug or trace calls cost 2x, so historical and trace workloads pay $4.90 per million.
  • Overage runs $5-20 per million depending on plan, well above the included rate.
  • Shared plans top out at 600 RPS, below Dwellir and level with dRPC Scale.

Best For

Enterprise and institutional teams building on Ethereum that need SOC 2 documentation and per-request pricing, without hiring dedicated protocol DevOps engineers.


3. dRPC - Decentralized Network with Built-In MEV Protection

dRPC

dRPC takes a different architectural approach: it aggregates Ethereum infrastructure from independent node operators across geo-distributed clusters in the US, EU, and APAC. Traffic routes automatically based on latency, availability, and geography, with failover between operators. If one operator goes down, requests reroute transparently.

The standout feature for Ethereum is built-in MEV protection, routing transactions through private channels to shield them from front-running and sandwich attacks. Pricing does not depend on the method: every method costs 20 CU, archive and trace included. The $49 Pro plan covers about 10M requests, or $4.80 per million calls, and overage costs $6.00 per million.

Key Features

  • Decentralized Routing: Traffic fails over automatically between vetted node operators.
  • MEV Protection: Built-in protection against front-running and sandwich attacks.
  • Flat Pricing: 20 CU for every method, archive and trace at the same price.
  • Throughput: 300 RPS on Pro and 600 RPS on Scale; unlimited only on Enterprise.
  • Debug and Trace APIs: Included on paid plans.

Pricing Structure

PlanMonthly CostIncludedRPSEffective $/1M CallsOverage $/1M Calls
Free$0210M CU (public nodes, ~10.5M calls)100$0-
Pay as you go$6/1M requestsNo commitment100$6.00-
Pro$49163M CU (~10M calls)300$4.80$6.00
Scale$199664M CU (~47M calls)600$4.20$6.00
EnterpriseFrom $990Volume discounts, dedicated clustersUnlimitedCustomCustom

The free tier at 210M compute units per month is the most generous in this comparison, though it runs on public nodes.

Pros and Cons

Advantages:

  • MEV protection included, important for Ethereum DeFi applications handling significant value.
  • Decentralized operator pool removes single-vendor downtime risk.
  • Every method costs the same, archive and trace included: $4.80 per million on Pro, $4.20 on Scale.
  • Most generous free tier for development and testing.

Considerations:

  • About 2.4 times Dwellir's and twice Chainstack's per-call price on the Pro plan, and $6.00 per million on overage.
  • Latency can vary depending on the underlying operator serving your request, and the operator is not disclosed.
  • Less centralized support compared to vertically integrated providers.

Best For

DeFi applications that require MEV protection, teams prioritizing uptime through operator diversity, and projects seeking a high-throughput secondary provider for redundancy.


4. Infura - Battle-Tested Ethereum Infrastructure

Infura

Infura has operated Ethereum infrastructure since 2016 and remains one of the most widely used providers in the ecosystem. As the default RPC backend for MetaMask, it handles an enormous share of Ethereum network traffic daily. Consensys backs the platform, which supports Ethereum mainnet and testnets with both HTTPS and WebSocket connections.

Where Infura stands apart is MEV protection through Flashbots integration, routing transactions through private mempools to shield them from front-running and sandwich attacks. For DeFi applications handling significant value, this is a meaningful security feature.

Key Features

  • MEV Protection: Flashbots integration routes transactions through private mempools.
  • Archive Data Access: Historical Ethereum state on all plans, at the same credit cost as recent state.
  • MetaMask Integration: Default provider for the most widely used Ethereum wallet.
  • HTTPS and WebSocket: Both connection methods for mainnet and testnets.
  • Operational Track Record: 10 years of Ethereum infrastructure operation.

Pricing Structure

PlanMonthly CostDaily CreditsCalls/Day on MixThroughputEffective $/1M CallsOverage $/1M Calls
Core (Free)$03M~30,800500 credits/s (~5 req/s)$0-
Developer$5015M~153,800 (~4.6M/mo)4,000 credits/s (~41 req/s)$10.83Add-on, $200 per 55M credits
Team$22575M~769,000 (~23.1M/mo)40,000 credits/s (~410 req/s)$9.75Add-on, $200 per 55M credits
EnterpriseCustomCustomCustomCustomCustomCustom

Credits are metered per method: eth_call, receipts, balances and sends cost 80, eth_getLogs 255, trace_transaction 300 and debug_traceTransaction 1,000. On the house mix that averages 97.5 credits per call. Quotas are daily and reset at 00:00 UTC. Exhausting the daily pool returns HTTP 402 and severs open WebSocket connections until the reset, which constrains bursty workloads that spike on specific days. Infura sells extra capacity as a $200 add-on for 55 million credits; its pricing page does not make clear whether those credits are daily or monthly, which decides whether the add-on is cheap overage or not.

Pros and Cons

Advantages:

  • MEV protection via Flashbots, critical for DeFi transaction security.
  • Deep Ethereum expertise built over a decade of infrastructure operation.
  • Archive data on all plans at no extra credit cost.
  • Strong ecosystem integration as MetaMask's default provider.

Considerations:

  • Daily credit caps (not monthly) limit flexibility for workloads with variable traffic.
  • Method-weighted credits: eth_getLogs costs $28.33 per million on Developer and debug_traceTransaction $111.11, so log and trace workloads cost far more than the headline rate.
  • Higher cost at scale. The Team plan at $225/month covers about 23 million calls a month on the house mix, against 150 million responses for $299 on Dwellir.
  • Smaller multi-chain footprint (40+ networks) than providers covering 100+.

Best For

Teams that prioritize MEV protection for DeFi transactions and value the reliability of the longest-running Ethereum infrastructure provider.


5. Ankr - Decentralized Multi-Chain Network

Ankr

Ankr operates a decentralized network of globally distributed nodes supporting Ethereum alongside 80+ other networks. A keyless public endpoint covers development, and the Premium tier adds higher throughput, WebSocket, debug and trace.

Ankr's pricing needs careful reading. The platform advertises $0.10 per million credits, one of the lowest per-unit rates in the market. But every EVM call costs 200 credits, against 20-26 units on most competitors, which works out to $20 per million calls. The upside of that flat weight is predictability: eth_call, eth_getLogs, archive and trace all cost the same, so the bill tracks call count exactly.

Key Features

  • Flat Per-Call Weight: 200 credits for every EVM method, archive and trace included.
  • Decentralized Architecture: Distributed node network reduces single points of failure.
  • Multi-Chain Hub: Single platform covering 80+ networks.
  • Public and Premium Endpoints: Free tier for development, Premium for production.
  • Simple Integration: Standard JSON-RPC interface with minimal setup.

Pricing Structure

PlanMonthly CostIncludedRPSEffective $/1M CallsOverage $/1M Calls
Public$0Keyless, ~1,800 req/min~30$0-
Freemium$0200M credits (~1M calls)Public limits$0-
Premium PAYG$10 minimum depositUsage-based~1,500$20.00$20.00
Deal$500-3,000Credits +20% bonus~1,500$16.67-

Premium allows a 10,000-block eth_getLogs range; the public endpoint allows 1,000. The RPS figures come from Ankr's documentation as of late September 2026 and were not rechecked.

Pros and Cons

Advantages:

  • The same price for every method, so trace-heavy and log-heavy workloads cost no more per call than simple reads.
  • Pay-as-you-go from a $10 deposit, with no monthly commitment.
  • Decentralized network architecture and multi-chain support.
  • Deal packages add 20% bonus credits, bringing the rate to $16.67 per million.

Considerations:

  • At $20 per million calls, the highest per-call rate in this comparison.
  • Per-credit pricing ($0.10/M) hides the per-call cost behind the 200-credit weight.
  • WebSocket, debug and trace only on Premium.
  • No MEV protection, and less tooling (analytics, simulation, enhanced APIs) than platform providers.

Best For

Teams that value a flat per-call price across every method and a decentralized network, and whose volume is low enough that $20 per million is acceptable.


6. GetBlock - Simple Deployment with Regional Endpoints

GetBlock

GetBlock provides Ethereum node access through a straightforward interface that prioritizes simplicity. Regional data centers in Frankfurt, New York, and Singapore deliver consistent latency, and shared, flat-rate and dedicated options cover different performance requirements. GetBlock supports JSON-RPC and WebSocket connections, lists 130+ networks and now attests SOC 2 Type II.

Key Features

  • Instant Node Access: No synchronization wait. Connect immediately to Ethereum endpoints.
  • Regional Endpoints: Frankfurt, New York, and Singapore data centers.
  • Limitless Nodes: One chain, flat monthly fee, no CU metering.
  • SOC 2 Type II: Audit documentation for regulated teams.
  • JSON-RPC and WebSocket: Both connection methods supported.

Pricing Structure

PlanMonthly CostCUCalls CoveredRPSEffective $/1M CallsOverage $/1M Calls
Free$050K/day~2,500/day20$0-
Starter$4990M4.5M250$10.89Top-up (price not published)
Growth$99185M9.25M300$10.70Top-up (price not published)
Advanced$199385M19.25M450$10.34Top-up (price not published)
Scale$349700M35M600$9.97Top-up (price not published)
Pro$499 ($399 yearly)1B50M800$9.98 ($7.98 yearly)$8.00
Premium$699 ($559 yearly)1.6B80M800$8.74 ($6.99 yearly)$7.00
Enterprisefrom $999CustomCustomCustomCustomCustom
Limitless Node (one chain, flat)Monthly CostCalls Covered at Full RPSEffective $/1M Calls
Full, 25 RPS$15065M$2.31
Full, 50 RPS$300130M$2.31
Full, 150 RPS$500390M$1.28
Full, 300 RPS$1,000780M$1.28
Archive, 15 / 30 / 50 / 100 RPS$150 / $300 / $500 / $1,00039M-260M$3.85

GetBlock prices each call as chain multiplier times method multiplier. Ethereum's chain multiplier is 20, so a standard call costs 20 CU and debug_traceTransaction 40 CU. Requests on an archive endpoint cost double (40 CU) and debug on archive six times (120 CU).

Pros and Cons

Advantages:

  • Published CU formula (chain multiplier x method multiplier) that is easy to reproduce.
  • The Limitless full node at 150 or 300 RPS is the lowest flat rate in this comparison, $1.28 per million at full use.
  • SOC 2 Type II attestation.
  • Multiple regional endpoints for latency optimization.

Considerations:

  • Archive and debug calls cost 2x, and debug on archive 6x, so the price moves with the method mix.
  • Overage below the Pro plan is a top-up whose price is not published.
  • Shared plans top out at 800 RPS, below Dwellir.
  • No MEV protection, and limited enhanced APIs.

Best For

Teams with steady, predictable Ethereum traffic on one chain that can use a Limitless node at full capacity, and small teams that want quick deployment.


7. QuickNode - Global Low-Latency Edge Network

QuickNode

For latency-sensitive Ethereum workloads, QuickNode routes requests through a global edge network that directs traffic to the nearest available node. The platform combines standard RPC access with Streams for real-time event streaming, webhooks for notifications, and dedicated node options for workloads that require isolated resources.

QuickNode charges 20 API credits for a standard Ethereum call, 40 for debug and trace, and 80 for large calls such as txpool_content and trace_replay*. It holds SOC 1 Type 2, SOC 2 Type 2 and ISO 27001.

Key Features

  • Global Edge Network: Automatic routing to nearest regions for minimal latency.
  • Streams and Webhooks: Real-time event streaming for monitoring on-chain activity.
  • Dedicated Nodes: Isolated infrastructure for guaranteed, deterministic performance.
  • Compliance: SOC 1 Type 2, SOC 2 Type 2 and ISO 27001.
  • 24/7 Support: Round-the-clock assistance from infrastructure specialists.

Pricing Structure

PlanMonthly CostAPI CreditsRPSEffective $/1M CallsOverage $/1M Calls
Free trial$0 (1 month)10M15$0-
Build$4980M50$12.25$12.40
Accelerate$249450M125$11.07$11.20
Scale$499950M250$10.51$10.60
Business$9992B500$9.99$10.00
EnterpriseCustomCustomCustomCustomCustom

Annual billing takes about 30% off. Trace and debug are not on the free trial; they start on Build. Streams, Functions, and dedicated node clusters cost extra.

Pros and Cons

Advantages:

  • Consistently low latency through global edge routing.
  • Streams and webhooks simplify event-driven Ethereum architectures.
  • SOC 1, SOC 2 and ISO 27001 documentation.
  • Strong documentation and responsive 24/7 support.

Considerations:

  • $12.25 per million calls on Build, about six times Dwellir's rate, and $9.99 even on the $999 Business plan.
  • Debug and trace calls cost double, and large calls four times.
  • Shared throughput tops out at 500 RPS, on the $999 plan.
  • No built-in MEV protection; add-ons increase total spend.

Best For

Latency-sensitive applications like trading platforms, arbitrage bots, and DeFi aggregators where response time matters more than cost per call, run by teams comfortable managing credit-based billing.


Alchemy

For teams that need more than raw RPC access, Alchemy provides a development platform with enhanced APIs for NFTs, tokens, and wallet activity that reduce custom indexing work. Transaction simulation catches errors before on-chain submission, and an analytics dashboard tracks request volumes, latency, and per-method compute unit consumption.

Alchemy supports Ethereum mainnet and testnets with HTTP and WebSocket connections. The cost is the highest of the compute-unit providers here: weights run from 10 CU for eth_blockNumber to 60 for eth_getLogs, which averages 25.9 CU per call on the house mix, or $13.60 per million calls.

Key Features

  • Enhanced APIs: NFT, Token, Transfers, and Notify APIs reduce the need for custom indexing infrastructure.
  • Transaction Simulation: Validate transactions before submitting them on-chain to catch reverts and errors.
  • Analytics Dashboard: Per-method compute unit tracking, latency breakdowns, and request volume monitoring.
  • SDK Coverage: TypeScript and Python SDKs for rapid integration.
  • Debug and Trace APIs: Available on Ethereum on paid usage.

Pricing Structure

PlanMonthly CostIncludedThroughputEffective $/1M CallsOverage $/1M Calls
Free$030M CU (~1.16M calls)300 CU/s (15 req/s)$0-
Pay as you go$0.525/1M CUUsage-based10,000 CU/s (300 req/s) included$13.60$13.60
EnterpriseCustomCustomCustomCustomCustom

Extra pay-as-you-go throughput costs $160 per month per 5,000 CU/s block, up to a 30,000 CU/s self-serve cap, so reaching the cap adds $640 a month. The flat $0.525 per million CU does not fall with volume.

Pros and Cons

Advantages:

  • Mature platform with comprehensive documentation.
  • Enhanced APIs minimize custom development for NFT, token, and wallet features.
  • Strong developer experience with SDKs, webhooks, and analytics tooling.
  • Enterprise SLAs and dedicated support available.

Considerations:

  • The highest cost per call of the compute-unit providers here: $13.60 per million on the house mix, $31.50 per million eth_getLogs and $21.00 per million debug_traceTransaction.
  • Throughput above 300 requests per second costs extra each month.
  • No MEV protection included.
  • Platform complexity may exceed the needs of teams that only require standard RPC access.

Best For

Teams building Ethereum applications that will use the enhanced APIs, simulation and analytics enough to justify paying about seven times Dwellir's rate per call.


Feature Comparison Table

ProviderFree TierEntry PaidEffective $/1M CallsArchive on EthereumWSSDebugTracegetLogs CapPricing UnitNetworks
Dwellir100K/day$49/mo$1.96YesYesYesYes500 blocks (Developer), 10,000 (Growth+)1 response150+
Chainstack3M RU/mo$49/mo$2.45Yes (2 RU)YesYes (2 RU)Yes (2 RU)Not stated1 RU (2 archive)70+
dRPC210M CU/mo$49/mo$4.80YesYesPaid plansPaid plansNot stated20 CU flat130+
Infura3M credits/day$50/mo$10.83YesYesDeveloper+Developer+Not statedCredits (~97.5/req)40+
Ankr200M credits/mo$10 deposit$20.00YesPremiumPremiumPremium10,000 blocks (Premium)200 credits/call80+
GetBlock50K CU/day$49/mo$10.89Yes (2x CU)YesYes (2x)Yes (2x)Not statedCU (20/req)130+
QuickNode10M credits, 1 month$49/mo$12.25YesYesPaid onlyPaid onlyNot stated20 credits/call75+
Alchemy30M CU/mo$0.525/1M CU$13.60YesYesPaid onlyPaid onlyNot statedCU (~25.9/req)100+
FeatureDwellirChainstackdRPCInfuraAnkrGetBlockQuickNodeAlchemy
Max RPS (Shared)5,000 (10,000 burst)600600~410 calls/s on the mix~1,500800500300 req/s included, ~1,150 eth_call/s at 30,000 CU/s
MEV ProtectionNoNoYesYes (Flashbots)NoNoNoNo
SOC 2NoYes (Type II, plus ISO 27001)NoNoNoYes (Type II)Yes (Type 2, plus SOC 1 and ISO 27001)No

True Cost: Price Per Million API Calls

Comparing RPC providers on advertised "compute units" or "credits" is misleading because each provider assigns a different weight to the same API method. The only way to compare them is to convert each one to dollars per million calls for the methods an application actually makes, using the weight each provider assigns to each method.

The totals below use a mostly-reads mix: 40% eth_call, 25% receipts, 15% eth_blockNumber, 10% eth_getLogs over small ranges, 5% eth_getBalance and 5% eth_sendRawTransaction, all on recent blocks.

ProviderWeight per eth_callAverage per call on the mixUnit Type
Dwellir11Response
Chainstack11Request unit
dRPC2020Compute unit
GetBlock2020Compute unit
QuickNode2020API credit
Alchemy2625.9Compute unit
Infura8097.5Credit
Ankr200200Credit

Method by method, in dollars per 1M calls at each plan's included rate:

MethodDwellir (Developer)Chainstack (Growth)dRPC (Pro)QuickNode (Business)GetBlock (Starter)Infura (Developer)Alchemy (PAYG)Ankr (PAYG)
eth_call$1.96$2.45$4.80$9.99$10.89$8.89$13.65$20.00
eth_getTransactionReceipt$1.96$2.45$4.80$9.99$10.89$8.89$10.50$20.00
eth_getLogs$1.96$2.45$4.80$9.99$10.89$28.33$31.50$20.00
eth_sendRawTransaction$1.96$2.45$4.80$9.99$10.89$8.89$21.00$20.00
debug_traceTransaction$1.96$4.90$4.80$19.98$21.78$111.11$21.00$20.00

Chainstack also charges 2 request units for reads 127 or more blocks behind the tip, and GetBlock doubles every call on an archive endpoint.

Effective Price per Million Calls

One denominator for every provider: dollars per 1M Ethereum calls under the house mix, at the entry paid plan and at the best self-serve rate, with overage alongside.

ProviderEntry Paid PlanEffective $/1M CallsBest Self-Serve RateOverage $/1M Calls
DwellirDeveloper $49$1.96$1.83 (Unlimited Node, 25 RPS)$2.00-5.00
ChainstackGrowth $49$2.45$2.45 (Growth)$5.00-20.00
dRPCPro $49$4.80$4.20 (Scale)$6.00
InfuraDeveloper $50$10.83$9.75 (Team)Add-on, $200 per 55M credits
GetBlockStarter $49$10.89$6.99 (Premium, yearly); $1.28 (Limitless full node, 150+ RPS)$7.00-8.00 (Pro/Premium)
QuickNodeBuild $49$12.25$9.99 (Business)$10.00-12.40
AlchemyPay as you go$13.60$13.60$13.60
AnkrPremium PAYG$20.00$16.67 (Deal)$20.00

What That Costs at Volume

Plans step at fixed tiers, so monthly bills differ from the per-million rates. Same mix, list prices.

Provider10M req/mo50M req/mo100M req/mo
GetBlock (Limitless, full node)$150$150-300$300-500
Dwellir (metered)$49$174$299
Chainstack$49$199$449
Dwellir (Unlimited Node)$119$119-479$479
dRPC$49$217$517
GetBlock (shared)$199$499~$839
QuickNode~$123~$526$999
Infura$225~$625~$1,225
Alchemy~$136~$680~$1,360
Ankr$200$1,000$2,000

At 10M requests, Dwellir's $49 ties Chainstack and dRPC Pro. Among metered plans, Dwellir is the lowest at 50M and 100M, against $217 and $517 on dRPC Scale with overage. GetBlock's single-chain Limitless full node is the cheapest flat option at 100M if traffic stays under its RPS cap, without archive. Infura's 50M and 100M figures assume the $200 add-on credits are daily; if they are monthly, those volumes need an Enterprise contract. The Unlimited Node at 50M is $119 if average traffic stays under 25 RPS and $479 for the 100 RPS tier.


Methodology

How the numbers and the order in this post were produced, so you can reproduce or dispute them.

Ranking: this is an editorial ranking by Dwellir, the publisher of this post, and Dwellir is one of the providers in it. It weighs three things: the effective cost per million calls on the house mix, how predictable the bill is when your method mix, block age or volume changes, and what the plans include (free tier, archive, debug and trace, MEV protection or compliance). No single criterion sorts the list, so a provider can sit above a cheaper one. The table gives the reason for each position:

RankProvider$/1M on the mix (entry plan)How the price moves with the method mixWhy this position
1Dwellir$1.96Flat: 1 credit for every method, archive, debug and trace includedLowest metered rate and no method weighting
2Chainstack$2.45Near flat: 1 RU, 2 RU for archive reads, debug and traceSecond-lowest rate, plus SOC 2 Type II and ISO 27001
3dRPC$4.80Flat: 20 CU for every method, archive and trace includedFlat pricing, MEV protection and 600 RPS on Scale
4Infura$10.83Weighted: 80 to 1,000 credits per method, daily quotaLower mix cost than GetBlock, QuickNode, Alchemy and Ankr at entry, plus Flashbots MEV protection
5Ankr$20.00Flat: 200 credits for every methodHighest rate here, but every method costs the same 200 credits and archive is on every plan
6GetBlock$10.89Mostly flat: 20 CU, 2x for archive and debug, 6x for debug on archiveLow flat-rate Limitless option, but archive and debug double the shared price and lower-tier overage is unpublished
7QuickNode$12.25Mostly flat: 20 credits, 2x debug and trace, 4x large callsHigher entry rate than GetBlock ($12.25 vs $10.89), 2x debug and trace and 4x large-call multipliers, and a one-month free trial without debug or trace
8Alchemy$13.60Weighted: 10 to 60 CU per methodHighest cost of the method-weighted providers, and extra throughput costs extra

Cost per million is the monthly price of each provider's entry paid plan divided by the number of calls its included volume buys, after applying the provider's own weight for each method in the house mix. Providers without a fixed bundle (Alchemy, Ankr) use their metered rate. The eth_call column in the numbers table applies the same calculation to eth_call alone.

Unit weights come from each provider's published method-cost table: Alchemy compute unit costs, Infura credit costs, QuickNode API credits, GetBlock's formula (chain multiplier 20 x method multiplier), dRPC's flat 20 CU, Ankr's 200 credits, and Chainstack's request-unit rules. Dwellir counts one unit per response.

RPS cap is the highest rate limit on a shared plan with a published price, converted to eth_call per second where the provider meters in units per second (Alchemy, Infura). Burst allowances are noted where published. Flat-rate products are compared in which RPC provider has the highest RPS.

Archive and WSS mean the provider serves historical state and WebSocket subscriptions on Ethereum mainnet on its standard shared plans. "Premium only" means the free tier lacks them.

Not measured here: latency, error rates and data freshness. Those depend on your region and method mix. Run a short benchmark from your own infrastructure against the two or three providers this table narrows you to before committing.

Not confirmed: whether Infura's $200 add-on of 55 million credits is daily or monthly, and Ankr's RPS figures (from its documentation in late September 2026).

Chart: the cost chart shows eth_call cost only, which did not change at the October check.

Verification dates: plan prices, unit weights and rate limits were checked against each provider's pricing and documentation pages on 2026-10-07, except where noted above (dRPC and Alchemy rechecked 2026-10-21). The modified date at the top of this post moves whenever a figure is rechecked.


Recommendations by Use Case

For DeFi Production and General Ethereum Development: Dwellir provides the strongest cost predictability for Ethereum workloads where DeFi method mixes make compute unit pricing unpredictable. The 1:1 credit model means debug_traceTransaction costs the same as eth_blockNumber, which matters when your application blends lightweight reads with heavy trace and log queries. For MEV-sensitive transactions specifically, pair Dwellir with dRPC or Infura for transaction submission through protected channels.

For Enterprise and Regulated Teams: Chainstack combines SOC 2 Type II and ISO 27001 documentation with per-request pricing at $2.45 per million. Multi-cloud deployment across AWS, GCP, and Azure with role-based access controls meets institutional infrastructure standards. GetBlock and QuickNode also hold SOC 2 reports, at higher per-call prices.

For MEV-Sensitive Applications: dRPC combines built-in MEV protection with a generous free tier and up to 600 RPS on its $199 Scale plan. Infura provides MEV protection through Flashbots with the longest operational track record on Ethereum. Either serves as a primary or complementary provider where front-running protection is non-negotiable.

For Steady High Volume on One Chain: GetBlock's Limitless full node at 150 or 300 RPS works out to $1.28 per million at full use, without archive. Dwellir Unlimited Nodes cost $1.83-1.85 per million at full use, on the same endpoint and key as the metered plans.


Conclusion

For most Ethereum development and production workloads, Dwellir delivers the strongest combination of transparent pricing, full archive access, and multi-chain coverage. The 1:1 credit model eliminates the compute unit complexity that makes Ethereum infrastructure costs unpredictable, which is particularly valuable given the varied method mix typical of DeFi applications. Trace and debug APIs come included on all paid plans at no premium, and 150+ network coverage means the same API key works across Ethereum L1 and its L2 ecosystem.

Chainstack is the runner-up: near-flat per-request pricing at $2.45 per million, plus SOC 2 and ISO 27001 documentation. For MEV protection on high-value DeFi transactions, dRPC and Infura stand out.

Frequently Asked Questions

What is the cheapest Ethereum RPC provider?

On a metered plan, Dwellir: $1.96 per million calls on the $49 Developer plan, the same price for every method. Chainstack Growth is next at $2.45. For steady high volume on one chain, GetBlock's Limitless full node works out to $1.28 per million at 150 or 300 RPS if you use the full capacity, without archive.

Do Ethereum RPC providers include MEV protection?

Not all providers include MEV protection. Infura and dRPC offer Flashbots integration for private transaction routing, while providers like Dwellir and Alchemy require a separate MEV solution.

What is the difference between archive and full Ethereum nodes?

Full nodes store recent blockchain state, while archive nodes preserve the complete historical state since genesis. Archive access is essential for analytics, block explorers, and DeFi applications querying past balances or contract states.

How do compute units affect Ethereum RPC pricing?

Providers like Alchemy and Infura charge different amounts per method. On a typical read-heavy mix an Ethereum call averages 25.9 CU on Alchemy and 97.5 credits on Infura, against 1 credit on Dwellir. Multiply the advertised per-unit price by the weight to get the true cost per call: $13.60 per million on Alchemy and $10.83 on Infura Developer, against $1.96 on Dwellir.

Which Ethereum RPC provider has the highest rate limit?

On shared self-serve plans, Dwellir's Scale plan allows 5,000 responses per second with bursts to 10,000. Ankr allows about 1,500 RPS per endpoint, GetBlock 800, Chainstack 600, dRPC 600 on its $199 Scale plan, QuickNode 500 and Infura about 410 calls per second on the mix. Alchemy's pay-as-you-go plan includes 300 requests per second and can be raised to 30,000 CU/s, about 1,150 eth_call per second, for $640 more per month.

Which Ethereum RPC providers include archive and WebSocket access?

Dwellir, Chainstack, dRPC, Infura, GetBlock, QuickNode and Alchemy all serve Ethereum archive state and WebSocket subscriptions on their standard paid plans. Chainstack bills archive reads at 2 request units and GetBlock at double compute units. Ankr serves archive but limits WebSocket, debug and trace to its Premium tier.

How is this list ranked?

It is an editorial ranking by Dwellir, the publisher. It weighs three things: the effective cost per million calls on a read-heavy mix, how predictable the bill is when the method mix changes, and what the plans include, such as archive, debug and trace or MEV protection. No single criterion sets the order; the methodology section gives the reason for each position.

Ready to build on Ethereum? Start with Dwellir's Free plan to test your integration, or contact the Dwellir team to discuss infrastructure requirements for your production deployment.

Start free.1 response = 1 credit.

100,000 responses a day at 20 per second, on 150+ networks. Upgrade when you need more.