5 Best RPC Node Providers in 2026 (Free + Paid)

Most teams that use CoinAPI start with exchange data. Trades, quotes, order books, candles… the market side of the stack.

But the moment a strategy touches a DEX pool, a bridge, a stablecoin treasury or a perp on Hyperliquid, it needs a second feed. That feed does not come from an exchange. It comes from a blockchain node, and almost nobody runs that node themselves. They rent access to one through an RPC provider.

Pick the right provider and onchain reads feel like any other API call. Pick the wrong one and you learn about compute units, rate limits and stale blocks at the worst possible moment.

This guide ranks 5 RPC node providers that publish their prices and offer a free way in: Dwellir, Chainstack, Infura, QuickNode and Lava Network. The order is an editorial selection for trading and data teams, not a measured ranking. Pricing and limits were checked on November 1, 2026.

Where an RPC node provider sits between your application and the chain, next to the market data layer

What an RPC Node Provider Actually Does

A blockchain node stores the chain, validates blocks and answers questions about state. An RPC provider runs fleets of those nodes and exposes them over HTTPS, WebSocket and, increasingly, gRPC. Your code sends a JSON-RPC request. The provider routes it to a healthy node and returns the answer.

Three kinds of traffic flow through that pipe:

• Reads: balances, contract state, logs, blocks, receipts
• Writes: signed transactions you want broadcast to the network
• Streams: new blocks, pending transactions, program updates, order book diffs

The method names are standardized. On Ethereum they follow the execution-apis specification, which grew out of EIP-1474. On Solana they follow the cluster RPC methods. What is not standardized is everything around the call. How it is metered. How fast it returns. How far back the data goes. What happens when a node falls behind.

That is where providers differ, and that is what this guide compares.

One thing to say upfront. ethereum.org’s own nodes-as-a-service guide puts the trade-off plainly: “By using a node service you are centralizing the infrastructure aspect of your product.” Every provider below is a convenience over running your own node. Some of them, Lava most of all, are built to soften that trade-off. None of them remove it.

How the 5 Providers Meter a Call

Pricing pages look alike. Plan names, a price, a big number. The big number means something different at every provider, and that difference decides your bill.

5 billing models, one eth_call: what each provider charges for the same request

• Dwellir charges 1 API credit per response, whatever the method. A debug trace costs the same as a balance check.
• Chainstack charges request units. A full-node call is 1 unit, an archive call is 2, and debug or trace calls on Global Nodes bill at 2 as well.
• Infura weights by method. An eth_call costs 80 credits, eth_getLogs costs 255, a debug_trace call costs 1,000. Quotas are daily, not monthly.
• QuickNode weights by chain. Every Ethereum, Base or Arbitrum call costs 20 credits, Solana costs 30, Bitcoin costs 10. Trace and debug methods double the chain rate.
• Lava Network meters compute units. A light call costs less than a heavy one. The protocol’s Ethereum spec weights eth_call at 20 CU and eth_getLogs at 80 CU.

The practical consequence: on Infura a debug trace costs 12.5 times an eth_call. On Dwellir it costs the same. A workload that reconstructs DEX fills or MEV paths feels that gap on every call. A simple balance poller barely notices it.

Free Tiers Compared

Every provider here offers something for $0. What that something buys varies by nearly two orders of magnitude.

Free tier allowance converted to Ethereum eth_call equivalents per month

Converted to Ethereum eth_call equivalents, Dwellir and Chainstack both give roughly 3 million calls a month. Infura’s 3 million daily credits translate to about 37,500 eth_call requests a day, or 1.1 million a month. QuickNode’s trial covers about 500,000 Ethereum calls, once. Lava’s Hobby plan covers about 37,500 calls a month at the protocol’s 20 CU weight.

Two caveats matter for production. QuickNode has no permanent free tier. Its $0 plan is a one-month trial and the account is deactivated at the end. Infura’s free throughput is 500 credits a second, which is roughly six eth_call requests a second, a limit a single busy bot can hit.

Chain coverage against free allowance, bubble size showing what the entry paid plan buys.

The 5 Best RPC Node Providers in 2026

1. Dwellir - Flat billing, 150+ networks, built for Hyperliquid

Dwellir runs RPC and API infrastructure for 150+ blockchain networks on its own bare-metal servers in North America, Europe and Asia. Every response costs 1 API credit, including trace and debug calls. Plans start free and scale to 5,000 requests per second. Dwellir is working toward ISO 27001 and SOC 2 Type 2 certification.

For CoinAPI readers the Hyperliquid stack is the headline. Dwellir runs one of the most complete Hyperliquid stacks available from a single provider: HyperEVM RPC, the HyperCore Info API, gRPC streams of every node feed, L2 and L4 order book WebSockets, a historical data archive, and dedicated node clusters. Its nodes run in Tokyo, next to the Hyperliquid validators. In an October 2026 benchmark from Tokyo, Dwellir had the fastest WebSocket order books of the providers tested.

The latency figures below come from Dwellir’s own test, run from AWS Tokyo on October 28, 2026 against Hydromancer and the public Hyperliquid API, with the method linked at the end of the list.

Low latency:

• Hyperliquid nodes and relays run in Tokyo, where most of the validators are. Order book servers run in Tokyo and Singapore.
• In a benchmark from AWS Tokyo on 28 October 2026, Dwellir had the fastest WebSocket order books tested: a median of 177 ms for the L2 book and 190 ms for the L4 book. That is 8 to 27 ms ahead of Hydromancer and about 100 ms ahead of the public Hyperliquid API.
• Dwellir’s L2 book sends about 14 updates a second. The public l2Book channel sends about one every 5 seconds.
• Full method and results: Hyperliquid Data Latency Benchmark

One note on the public feed. Hyperliquid’s own docs also offer a fast mode on l2Book, which returns 5 levels a side instead of the standard 20.

The full Hyperliquid stack, from one account:

• HyperEVM JSON-RPC (chain ID 999) over HTTPS and WebSocket, with archive, trace and debug at 1 credit per call
• HyperCore Info API for positions, balances, open orders and metadata, plus batch methods that return many wallets in one request
• gRPC streaming of all seven raw node feeds (blocks, fills, order statuses, raw book diffs, misc events, TWAP statuses, state snapshots), with cursor replay, plus 14 typed market streams for L2, L4, BBO, trades, candles and mids
• Order Book WebSocket with L2 depth beyond the public 20 levels, and L4 (every resting order with its owner and order ID)
• Historical archive: raw node data from January 2025, fills from March 2025, candles and ticks from July 2025, order events from January 2026, delivered over S3, CSV, Parquet or API
• Dedicated Node Clusters: two dedicated backend nodes with HyperEVM, Info, gRPC and the Order Book server included and unmetered
• Peering slots for teams that run their own Hyperliquid node

Pricing:

All shared plans bill 1 API credit per response. Yearly billing saves 14%.

Hyperliquid products are priced separately. Current prices are at dwellir.com/pricing.

Focus:

• One credit per response across 150+ networks, trace and debug included
• Hyperliquid order books, node feeds and archive from one account
• Bare-metal nodes on three continents, Tokyo for Hyperliquid

Best suited for:

• Trace-heavy or high-volume workloads that need a predictable bill
• Hyperliquid trading systems that want L4 depth and raw node feeds
• Teams that want many chains under one key

2. Chainstack - Managed nodes with the compliance file already done

Chainstack has run the node layer since 2018 from Singapore. Managed RPC covers 70+ chains, Ethereum, Solana and Bitcoin among them, over JSON-RPC and WebSocket, with gRPC on Solana, TRON and Sui. Global Nodes send each request to the nearest healthy region and fail over when a node falls more than 40 blocks behind. The platform handles 10B+ API calls a day across 10+ data centers at 99.99%+ uptime. Trust Wallet, Circle and TradingView are listed as customers.

Billing runs on request units. A full-node call is 1 unit, an archive call is 2. The free Developer plan gives 3 million units a month at 25 requests a second and never expires. Growth is $49 a month for 20 million units at 250 requests a second. That is the plan where archive data and the Debug and Trace API switch on. Pro is $199, Business is $499 and Enterprise starts at $990. Unlimited Nodes charge a flat fee from $149 a month with no meter. Dedicated nodes bill by the hour on Pro and above.

Solana trading teams get specific tooling. Trader Nodes push Warp transactions through bloXroute at $0.15 each. Chainstack is retiring its regional Trader Nodes on December 1, 2026, with Global Nodes taking their place on every chain they support and Warp staying available as a Global Node add-on. Yellowstone gRPC streams live data from validator memory, from $49 a month for two streams. Both need Growth or higher.

The compliance file is unusually complete for an RPC vendor: a SOC 2 Type II report in December 2025 and ISO 27001 certification in July 2026. An MCP server ships on every plan, including the free one. It deploys and manages nodes, searches docs and requests testnet funds. It does not answer chain-data queries, so your agent still needs the RPC endpoint for that.

Focus:

• 70+ chains with regional failover built into the endpoint
• Request-unit billing that a finance team can forecast
• Solana streaming and transaction propagation for trading bots

Best suited for:

• Bots that read raw chain state, stream events and submit transactions
• Multichain teams that need SOC 2 and ISO 27001 on file
• Anyone who wants a free tier that does not expire

Watch for: responses are raw chain state, so decoding and pricing stay on your side. Archive calls bill at double rate. The MCP server manages infrastructure rather than data.

3. Infura - The default endpoint inside MetaMask, now part of MetaMask Developer

Infura is the oldest name on this list and the one MetaMask talks to by default. It is now part of MetaMask Developer, with the same API keys and the same dashboard under the Consensys umbrella. Consensys announced in September 2026 that it will split into two companies by the end of the year, so the branding may move again.

The free Core plan gives 3 million credits a day at 500 credits a second, with full archive data and the Gas API included. Developer is $50 a month for 15 million daily credits at 4,000 credits a second and adds the Debug and Trace API. Team is $225 a month for 75 million daily credits at 40,000 credits a second. Enterprise is custom, with auto-scaling and committed SLAs. Quotas reset at 00:00 UTC every day, which suits steady traffic and punishes bursts.

Credits are weighted by method. Most Ethereum reads cost 80, eth_getLogs costs 255, trace methods cost 300 and debug traces cost 1,000. Solana requests cost 160 each, and Solana access is currently limited to select customers.

Network coverage is narrower than the others here. The docs list 27 chain families across 54 endpoints, including Ethereum, Arbitrum, Base, Optimism, Polygon, Linea, BNB Smart Chain, Avalanche, Bitcoin, Starknet, HyperEVM and Monad. What Infura adds is distribution. Its Decentralized Infrastructure Network (DIN) spreads traffic across partner operators. DIN went live as an EigenLayer AVS in November 2025, handling more than 13 billion monthly requests at the time. Failover protection, which forwards a request elsewhere when Infura itself has an outage, is a paid-tier feature on Arbitrum, Avalanche, Optimism and Polygon mainnets. The docs list it for the Growth and Custom plans, which now sit under Enterprise.

Two housekeeping notes. Infura’s IPFS service shut down on August 15, 2026. And the pricing page disagrees with itself on the free tier: the plan table and the docs say 3 million credits a day at 500 credits a second, while the FAQ on the same page says 6 million at 2,000. This guide uses the plan table and docs figures.

Focus:

• EVM mainnets and L2s with archive data on every plan
• Daily credit quotas with high per-second throughput on paid tiers
• Multi-provider distribution through DIN

Best suited for:

• Wallets and dapps that want the endpoint MetaMask already trusts
• Teams with steady, predictable daily volume
• Builders who need the Gas API alongside RPC

Watch for: method-weighted credits make logs and traces expensive. There is no public uptime SLA below Enterprise. Outages in November 2020 and April 2022, and the AWS incident of October 2025, all surfaced first inside MetaMask. That is what happens when one provider carries most of a wallet’s traffic.

4. QuickNode - The widest paid platform, no permanent free plan

QuickNode covers 77+ chains and 130+ networks, with archive to genesis on Ethereum and archive data on most other networks. By its own count it processed 5 trillion requests in 2025, roughly 14 billion a day. When Google Cloud decided to shut its Blockchain RPC and Blockchain Node Engine products on December 15, 2026, it named QuickNode as the recommended replacement.

The catch for budget-conscious teams is in the first row of the pricing page. QuickNode’s $0 plan is a one-month trial with 10 million credits at 15 requests a second. After the month, the account is deactivated. Overage is published, from $0.62 per million credits on Build down to $0.50 on Business. Annual billing takes 15% off.

Credits are weighted by chain rather than by method. Ethereum, Base, Arbitrum and Hyperliquid calls cost 20 credits, Solana 30, Sui and TON 40, NEAR 50, Bitcoin 10. Trace and debug methods double the rate.

Beyond raw RPC, QuickNode sells the plumbing around it. Streams delivers filtered chain data to webhooks, S3, PostgreSQL, Azure Blob or Kafka with backfill and reorg handling. Yellowstone gRPC covers Solana. Add-ons include a Solana priority fee API, Hyperliquid peering and Jito bundle submission. A hosted MCP server lets an agent manage endpoints and call RPC methods. Compliance is complete: SOC 1 Type 2, SOC 2 Type 2 and ISO 27001, with a contractual 99.99% uptime commitment on Enterprise.

Focus:

• 77+ chains with the deepest add-on catalog in the group
• Streams for pipelines that need chain data in a database, not a socket
• Enterprise compliance and contractual SLAs

Best suited for:

• Data teams that want chain events landing in Postgres or Kafka
• Solana and Hyperliquid systems that use gRPC and peering
• Teams migrating off Google Cloud’s blockchain products before December

Watch for: no free tier after the trial. QuickNode Functions is being deprecated, so do not build new workflows on it.

5. Lava Network - Decentralized routing across 20+ independent providers

Lava Network is a different kind of entry. It is a protocol, not a single data center. Independent node operators stake LAVA, serve requests and are scored each epoch on availability, latency, sync freshness and error rate. Your request goes through a gateway that pairs you with several providers at once. The gateway retries on alternative nodes, rejects stale responses and broadcasts transactions to all available providers simultaneously. If one operator fails, the next one answers.

Smart Router, an enterprise router that core contributor Magma Devs builds on the Lava protocol, sits in front of a customer’s existing RPC vendors. Fireblocks adopted it in 2025, and in February 2026 Lava announced that Kraken would integrate it too. The Gateway plans below are the standard product, not that enterprise router. Lava reports more than 229 billion requests served and 20+ independent providers with automatic failover, with 28+ networks reachable through a single endpoint.

Pricing on the website is metered in compute units. Going over a plan does not break the endpoint. The docs still show an older request-based ladder without prices, so read the website page, not the docs, when you budget.

Focus:

• Multi-provider routing with quality scoring at the protocol level
• Public, incentivized RPC for chains like NEAR, Starknet and Axelar
• The cheapest paid entry here at $29

Best suited for:

• Products that treat RPC centralization as a real risk
• Teams that want provider diversity without managing 5 contracts
• Cosmos, NEAR and Starknet builders already on Lava’s public endpoints

Watch for: Lava publishes no SOC 2 or ISO 27001 report, no formal SLA below Enterprise, and no independent latency benchmark covers it yet. In August 2026 the Lava Foundation asked whether the protocol should keep running its own chain. On October 2, 2026 governance proposal 69 passed with 89% in favour of moving forward with a migration to an EVM chain. No destination chain, technical plan or timeline was chosen in that vote, so follow it if you build on Lava.

Benchmark: 5 Providers on 6 Axes

The chart below scores each of the 5 providers from 1 to 5 on 6 axes: chain coverage, free tier, billing predictability, trading data tooling (streams, order books, gRPC), compliance and routing resilience. The scores are editorial judgments based on the published facts above, not measurements, and the ranking in this guide does not follow the totals.

Radar chart scoring Dwellir, Chainstack, Infura, QuickNode and Lava Network on 6 axes

Latency is the one axis the chart leaves out, because it depends on where you measure from. OpenChainBench is a community-run harness that polls Ethereum endpoints from Virginia, Amsterdam and Singapore. On October 31, 2026 it reported single-digit 24-hour p50 latencies for QuickNode and Chainstack and low tens of milliseconds for Dwellir, all at 100% success. Infura and Lava are not in its cohort. Measured from Tokyo against Hyperliquid order books, Dwellir’s own October benchmark came out fastest. Same provider, different region, different answer. Run your own test from the region your strategy lives in. That is also what CoinAPI’s Latency Route Map exists for on the market data side.

What a Month of Calls Costs

Converting 5 billing models into one number takes a fixed workload. The chart uses Ethereum eth_call requests spread evenly across a month. For each provider it picks the cheapest published plan whose included allowance covers the volume, with no overage and no annual discount.

Monthly list price for 10 million and 100 million Ethereum eth_call requests per provider

At 10 million calls a month, Dwellir and Chainstack both land on a $49 plan. Lava needs its $199 Starter plan because 10 million calls is 200 million CU. Infura needs Team at $225 because the daily quota on Developer runs out. QuickNode needs Accelerate at $249 because 200 million credits exceeds Build’s 80 million.

At 100 million calls a month, Dwellir’s Growth plan covers it at $299. Chainstack’s Business plan covers it at $499, and so does Lava’s Pro plan. QuickNode’s Business plan covers it at $999. Lava’s Pro plan and QuickNode’s Business plan land exactly on their included allowance at that volume, with no headroom. Infura’s largest published plan, Team, tops out at 75 million credits a day, so 100 million eth_call requests a month means an Enterprise contract.

Two of the providers publish per-unit overage, which changes the cheapest-bill answer. QuickNode’s Build plan plus 120 million extra credits at $0.62 per million comes to about $123 for 10 million calls. Chainstack’s Pro plan plus 20 million extra units at $12.50 per million comes to $449 for 100 million calls. Dwellir and Lava publish no per-unit overage, and Infura sells extra credits as a $200 bundle, so the chart compares included allowances only.

Change the workload and the picture moves. A getLogs-heavy indexer on Infura spends 255 credits a call. A Solana bot on QuickNode spends 30. A trace reconstruction on Dwellir spends 1. Run your own method mix through each provider’s table before you commit.

Feature matrix: archive, trace, WebSocket, gRPC, MCP, compliance, crypto payments, dedicated nodes and multi-provider routing per provider

Reliability Is a Layer, Not a Chain

RPC incidents rarely look like chain incidents. The chain keeps producing blocks. The nodes that answer your questions about it fall behind, time out or return stale state. Polygon Foundation’s account of an incident in December 2025 is a clean example of the difference:

Polygon Foundation (@0xPolygonFdn), December 17, 2025

This afternoon, Polygon PoS experienced an issue affecting a subset of RPC nodes. The network remained online and continued producing blocks throughout the incident, with no chain downtime.

The team quickly identified and rolled out a patch to operators to restore full service…

View on X

The same pattern played out in November 2020, when a consensus bug in an older Geth version stalled Infura’s Ethereum endpoints and exchanges including Binance paused ETH withdrawals, as The Block reported at the time. In October 2025 an AWS outage in us-east-1 left MetaMask users looking at zero balances, per Decrypt. Ethereum kept producing blocks on both days. The read layer did not keep up.

3 defaults protect a trading system from that class of failure:

• Two providers, one interface. Keep a second endpoint configured and fail over on error rate or block lag, not on a status page.
• Check block height. Compare the latest block from your provider against a second source before you trust a quote built on it.
• Separate reads from sends. A stale read costs you a bad signal. A dropped send costs you the trade.

For the chains where it is practical, running your own node is back on the table. Vitalik Buterin made the point in September 2026:

vitalik.eth (@VitalikButerin), September 26, 2026

Reminder: you can now sync an ethereum node within half a day and with aggressive settings the space it takes up on disk can be under half a terabyte.

EIP-4444 and hard work by client teams on optimizing snap sync has improved things a lot.

Glamsterdam will improve the sync…

View on X

A self-hosted node as the second source, with a provider carrying the bulk traffic, is a setup more trading desks are choosing. The public endpoints are not that second source. Solana’s clusters reference caps the public mainnet endpoint at 100 requests per 10 seconds per IP. The same page says it is “not intended for production applications”.

Which Provider for Which Workload

• Hyperliquid perps, order book strategies, trace-heavy analytics: Dwellir. Tokyo nodes, L4 books, one credit per response.
• Multichain products that need a compliance file and regional failover: Chainstack. 70+ chains, SOC 2 Type II, ISO 27001, Global Nodes.
• Wallet-facing EVM dapps with steady daily traffic: Infura. The endpoint MetaMask already uses, archive data on the free plan.
• Chain data pipelines into Postgres, Kafka or S3, Solana included: QuickNode. Streams, Yellowstone gRPC, add-ons.
• Products where provider diversity is a requirement, not a preference: Lava Network. Protocol-level multi-provider routing.

Most production systems end up with two of these. A common pair is a flat-billed primary for volume and a decentralized or second-vendor fallback for resilience.

If you want a wider field, CoinStats maintains a reviewed guide to RPC node providers that covers more generalist options. Supratip Banerjee’s roundup of crypto APIs on dev.to is useful for the split this guide takes for granted. RPC APIs give you the chain. Data APIs give you the market.

RPC for the Chain, CoinAPI for the Market

An RPC node tells you what a contract holds, what a pool quoted and whether a transaction landed. It does not tell you what Binance, Coinbase or OKX are quoting for the same asset, and it cannot normalize 400+ exchanges into one symbology.

That is the layer CoinAPI runs. Market Data API delivers real-time and historical trades, quotes and order books across 400+ exchanges over REST, WebSocket, FIX, JSON-RPC, MCP and S3, with 10+ years of history for backtests. For Hyperliquid specifically, CoinAPI’s L4 order data sits next to the HyperEVM reads you get from a node provider. Together they cover both halves of a DEX-aware strategy: the chain state from RPC, and the cross-venue price context from CoinAPI.

A typical stack looks like this:

• RPC provider for balances, pool state, event streams and transaction submission
• CoinAPI for exchange quotes, trades, order books, reference rates and historical data
• Your own service in the middle, comparing the two and deciding when onchain and offchain prices disagree

CoinAPI’s guides to the best Solana APIs and the best Ethereum APIs walk through that layering per chain, and the piece on why crypto data breaks explains what goes wrong when the two layers disagree and nobody checks.

FAQ

What is an RPC node provider?

A company that runs blockchain nodes and sells access to them over an API. Instead of syncing and maintaining a node, you send JSON-RPC requests to the provider’s endpoint and get chain data or transaction broadcasts back.

Which RPC provider has the best free tier?

By volume, Chainstack and Dwellir, at roughly 3 million Ethereum calls a month each with no expiry. Infura gives about 1.1 million eth_call requests a month with archive data included. Lava’s Hobby plan is smaller but reaches 28+ chains. QuickNode’s free plan is a one-month trial.

Why do the same requests cost different amounts at different providers?

Because each provider meters differently. Dwellir charges one credit per response. Chainstack charges request units with archive at double. Infura weights by method, QuickNode by chain, Lava by compute units. Run your own method mix through each pricing table before comparing plans.

Is a decentralized RPC network slower than a centralized one?

Not necessarily, but it is harder to verify. Lava routes each request to several scored providers and rejects stale responses, which adds resilience. No independent benchmark has published Lava latency figures yet, so test it from your own region.

Do I still need an RPC provider if I use CoinAPI?

If your system reads or writes onchain state, yes. CoinAPI covers exchange-level market data, reference rates and historical datasets. An RPC provider covers chain state and transaction submission. Most DeFi-aware trading systems use both.

Final Thoughts

5 providers, 5 ways to count a request. Dwellir makes the count trivial and brings one of the most complete Hyperliquid stacks from a single provider. Chainstack makes it forecastable and arrives with the audits done. Infura is the known quantity behind MetaMask. QuickNode is the broadest paid platform once the trial ends. Lava is the one built so that no single node operator carries your reads, with the gateway in front of them still one service to watch.

Whichever you pick, put the second endpoint in the config on day one, and keep the market data on a separate pipe. The chain tells you what happened. The market tells you what it was worth.

👉 Get Your API Key and Start with Free Credits

Pricing, limits and benchmark figures were checked on November 1, 2026 against each provider’s published pages. Plans change often; confirm current prices before committing. This article is for information only and is not investment advice.

Related Topics

• Best Solana APIs (2026): A Practical Guide for Builders
• Best Crypto APIs for AI Trading Bots, Quant Research & MCP Workflows (2026)
• Best Ethereum APIs - Simple Guide for Developers
• Best API Tools for Crypto Traders
• How to Reconstruct Hyperliquid L4 Order Books Correctly