An RPC provider is a service that runs blockchain nodes for you and lets your application read data and send transactions through an API. Most RPC providers speak the same protocol, so the real differences sit in five places: how they bill, how they limit traffic, which chains and interfaces they cover, what they promise on uptime, and how much isolation you can buy.
This comparison starts with the basics and works up to the trade-offs. It covers NOWNodes, Alchemy, QuickNode, Chainstack and Infura, using each company’s own pricing page as of September 2026. Prices change often, so re-check them before you budget.
Why Do Applications Need an RPC Provider?
Because running your own node is an operations job, not a one-time install. ethereum.org lists a 2 TB SSD as the minimum for an Ethereum full node, and the machine has to be patched and resynced through every network upgrade (ethereum.org). Archive mode, which keeps full historical state, needs from roughly 2 TB to more than 12 TB depending on the client and storage format, according to 7BlockLabs’ disk benchmarks.
An RPC provider takes over syncing, client upgrades and hardware. You get a URL and an API key. For a team building a wallet or a trading tool, that time is better spent on the product. The different types of blockchain nodes explain why some workloads need more than a basic full node.
What Should You Compare Between RPC Providers?
Compare seven things about any RPC provider, in this order of impact. The table lists what to check and why each one matters.
| Criterion | What to check | Why it matters |
|---|---|---|
| Billing unit | Requests, credits, compute units or flat RPS | Decides whether your bill is predictable |
| Rate limits | Requests or units per second, per plan | Decides what happens during a burst |
| Chain coverage | EVM only, or Bitcoin, Solana and others too | One account versus several vendors |
| Interfaces | WebSocket, gRPC, archive, trace and debug | Whether your app’s features work at all |
| Uptime and SLA | Page claim versus written contract | Whether downtime has any compensation |
| Isolation | Shared or dedicated infrastructure | Noisy neighbors, custom configuration |
| Support | Response times per plan | Who answers during an incident |
How Do RPC Provider Pricing Models Differ?
RPC providers bill in three ways: request quotas, weighted units and flat capacity. Only the first one bills every call the same.
- Request quota. One request is one count, whatever the method. NOWNodes’ shared plans work this way.
- Weighted units. Each method has a weight. Alchemy’s compute unit table puts
eth_blockNumberat 10,eth_getBalanceat 20,eth_callat 26 andeth_getLogsat 60. QuickNode and Infura use credits, and Chainstack uses request units (1 for a full-node call, 2 for an archive call). - Flat capacity. A fixed fee buys a request rate instead of a volume. Chainstack’s Unlimited Node starts at $149 a month for 25 RPS, and traffic above the cap is rejected.
Here’s why the difference matters. Take 10 million requests on Alchemy’s pay-as-you-go plan at $0.525 per million compute units, with the 30 million free units applied. As eth_call requests that costs about $120.75, and as eth_getLogs requests about $299.25. Same request count, 2.5 times the bill.
The table below converts list prices into cost per million calls, assuming the plan quota is fully used. Currencies are as published, euros for NOWNodes and dollars for the others.
| Plan | Unit | Cost per 1M calls |
|---|---|---|
| NOWNodes Pro (€20, 1M requests) | Request | €20.00 |
| NOWNodes Business (€200, 30M requests) | Request | €6.67 |
| Chainstack Growth ($49, 20M request units) | Request unit | $2.45 |
| Chainstack Business ($499, 200M request units) | Request unit | $2.50 |
Alchemy pay-as-you-go, eth_call | Compute unit | $13.65 |
Alchemy pay-as-you-go, eth_getLogs | Compute unit | $31.50 |
Read this carefully. At high volume, Chainstack’s request units come out cheaper per call than a flat request quota, and archive calls double that. A flat quota wins on forecasting, not always on unit price, and the table ignores overage rates, feature gating and chain coverage.
How Reliable Are Uptime and Latency Claims?
Treat them as claims until a contract says otherwise. Every RPC provider publishes numbers, but written SLAs tend to sit on the top tier: Alchemy lists signed SLAs on Enterprise, QuickNode lists contractual uptime SLAs on Enterprise, and Chainstack attaches its uptime SLA to Enterprise as well.
NOWNodes advertises 99.95% API uptime with roughly 0.2 second response times, and 99.99% for dedicated nodes. Those are product-page figures, not guarantees for every configuration. The gap between them is bigger than it looks: 99.99% allows about 53 minutes of downtime a year, while 99.95% allows about 4.4 hours.
The reliable check is your own. Send synthetic calls from the regions your users sit in for a week and track error rates and 95th-percentile latency.
Which Chains and Interfaces Do RPC Providers Cover?
Coverage differs across RPC providers more than headline numbers suggest. NOWNodes lists 120+ networks, including non-EVM chains such as Bitcoin, Litecoin, Dogecoin and Monero. Alchemy states 100+ chains, QuickNode roughly 79, and Infura stays close to Ethereum and its rollups.
Interfaces vary per network and per RPC provider. On NOWNodes, WebSocket and Blockbook are listed for 30+ networks and gRPC streaming for 25+, so a feature available on Ethereum may not exist on a smaller chain. Check the specific chain and interface pair in the node directory before you build on it.
When Do You Need Shared or Dedicated Infrastructure?
Shared plans cover development and moderate production traffic. A dedicated node is isolated for one customer and one network, which removes the quota and the noisy neighbors. Neither is universally better.
NOWNodes’ dedicated nodes let you pick the region and client, and they have no predefined RPS limit, so capacity is set by the allocated hardware. Chainstack enables dedicated nodes from its Pro plan, and QuickNode handles them through Enterprise agreements. Move once quotas or missing trace and debug methods start costing you more than a fixed server bill would.
How Do the Main RPC Providers Compare?
NOWNodes is a blockchain infrastructure provider offering shared and dedicated node access across 120+ networks, plus WebSockets, Blockbook, archive access, trace and debug methods, gRPC streaming and a market data API. The snapshot below places it next to four widely used RPC providers.
| Provider | Free tier | Billing unit | Chains | Notable |
|---|---|---|---|---|
| NOWNodes | 100,000 requests | Request | 120+ | Non-EVM coverage, dedicated nodes, gRPC |
| Alchemy | 30M CU, 25 RPS | Compute unit | 100+ | NFT and token APIs, webhooks |
| QuickNode | 10M credits, 15 RPS | API credit | ~79 | Streams, add-on marketplace |
| Chainstack | 3M request units, 25 RPS | Request unit | 70+ | Flat-rate Unlimited Node, dedicated from Pro |
| Infura | 3M credits/day, 500 credits/s | Credit | Ethereum-centric | MetaMask ecosystem fit |
Each of these RPC providers makes a different bet. Alchemy and QuickNode bundle application-level tooling and charge by method weight, which pays off for NFT apps and indexing pipelines but is harder to forecast. Chainstack sells flat capacity and enterprise deployment. Infura fits teams already inside Consensys tooling. NOWNodes bets on breadth and simple counting, so it suits products that span several chains, such as multi-asset wallets and exchanges, and it offers less pre-built application tooling.
Chain counts from any RPC provider are self-reported and shift over time. Confirm the exact network you need before committing.
How to Choose an RPC Provider
Work through five steps before you open any RPC provider’s pricing page:
- Log your real traffic. List your top methods and your monthly request volume, plus peak requests per second.
- Convert to each billing unit. Multiply your method mix by each RPC provider’s weights, then compare with the plan quota and overage rate.
- List chains and interfaces you need now and next year. Include WebSocket, archive and trace if there’s any chance you’ll use them.
- Separate claims from contracts. Ask which uptime figure is written into an SLA and at which plan tier.
- Test with your own load. Point staging traffic at two RPC providers for a week and compare latency and error rates from your regions.
Plans on NOWNodes’ pricing page and its shared nodes product are one reference point for step 2, since counting one request as one makes the arithmetic short.
Should You Use More Than One RPC Provider?
For production, usually yes. A single provider outage becomes your outage, and a second URL in the configuration costs little.
The libraries already support multiple RPC providers. Ethers.js’ FallbackProvider manages several providers to get “resilience by switching between slow or misbehaving nodes, security by requiring multiple backends to agree and performance by allowing faster backends to respond earlier,” per its documentation. Viem’s fallback transport can rank RPC providers every 10 seconds, weighting stability at 0.7 and latency at 0.3, and retries three times by default with exponential backoff.
The trade-off is a second bill and slightly different rate limits and quirks on each side. A common setup keeps one primary and one fallback, and uses quorum reads only where a wrong answer costs money.
Conclusion
RPC providers differ less in what they can do than in how they charge, limit and promise. Pick by billing unit first, because the same traffic can produce a bill that differs by 2.5 times depending on the methods you call. Then check chain and interface coverage, and only trust an uptime number that a contract backs.
There’s no single winner. A NFT app leans toward tooling-heavy platforms, a large indexer toward flat capacity, and a multi-asset wallet toward broad chain coverage with predictable counting, which is where NOWNodes fits. Measure your own traffic, run it through each pricing model and test two RPC providers side by side.
FAQ
Can I switch RPC providers without rewriting my code?
Usually yes. Standard JSON-RPC calls only need a new URL and API key. Provider-specific APIs, such as NFT endpoints or custom webhooks, are the parts that need migration work.
How do I choose an RPC provider for a production Web3 app?
Start with your real traffic, then filter by four production requirements: a written SLA, headroom above your peak requests per second, coverage of every chain and interface you use, and a fallback provider. Shortlist two RPC providers, run your actual workload through both for a week, and pick on measured error rates and latency rather than advertised numbers.
Are free public endpoints enough for production?
No, they’re built for prototyping. NOWNodes’ public endpoints, for example, are limited to 5 requests per second, which a single busy wallet can exceed.
What happens when I hit a rate limit?
The provider returns an HTTP 429 (Too Many Requests) response. Your app should retry with exponential backoff, which is also Alchemy’s recommendation for its throughput limits.
Does an RPC provider have access to my private keys?
No. Wallets sign transactions locally and send only the signed result. The RPC provider can still see which addresses you query and from which IP, so privacy-sensitive apps should factor that in.
Is a decentralized RPC network more reliable than one provider?
It can be. dRPC, for instance, routes requests across independent operators, which protects against a single node failing. Performance per request depends on which operator answers, so test it like any other provider.
