Last updated: 4 November 2026 · Data checked: 4 November 2026
Short answer: choose an RPC provider by scoring it on seven criteria: reliability, P95 latency, cost per request, rate limits, chain and data coverage, security and SLA, and support and tooling. Chainstack leads on cost per request in this comparison, but the right choice depends on how you weight those criteria for your app. Test your shortlist with your own traffic: a single latency number or a low entry price will not tell you how a provider behaves at peak load.
Quick picks (Ethereum mainnet, public data checked 4 November 2026):
- Lowest cost per request: Chainstack, about $2.45 per 1M requests on the Growth plan ($49 for 20M request units, 1 RU per request), against about $12.25 for Quicknode and about $14.04 for Alchemy (standard EVM calls on each vendor's roughly $49 plan).
- Widest chain list and highest SLA for Enterprises: Quicknode, with 77 self-serve mainnets and a 99.99% SLA with credits on Enterprise.
- Highest throughput around $49/month: Alchemy, with 300 RPS included on its pay-as-you-go plan, against 250 RPS on Chainstack Growth and 50 RPS on Quicknode Build.
What is an RPC provider, and why does the choice matter?
An RPC provider (also called a blockchain node provider) runs the nodes your app calls to read chain state and send transactions. When it slows down, serves a stale block or throttles you at peak, your users see a broken app. That is why a good RPC provider comparison looks past one benchmark and weighs cost, limits, reliability, compliance and support together.
The seven criteria below follow the pillars used on the Chainstack RPC provider comparison, which scores Chainstack, Quicknode and Alchemy on eight weighted pillars. Support and AI tooling are merged into one criterion here.
1. Reliability: availability, block freshness and data correctness
Reliability is the first thing to check because a fast provider that returns errors or stale data is worse than a slower one that does not.
- Availability: the share of requests that succeed, not time-based uptime. Ask for request-success data over a stated window.
- Block freshness: how often the provider's tip is within one or two blocks of the best tip in the region. Stale reads break DEX quotes, liquidations and balance checks.
- Data correctness: whether providers return the same results for the same query.
In the Chainstack methodology, reliability carries the largest default weight (25 of 100) for a production dApp. Availability uses a logarithmic nines scale: 99% or lower scores 0 and 99.99% or higher scores 100.
For measured results, see the monthly RPC providers for production workload comparison report (October 2026).
How to test it: run a 24-hour probe against each shortlisted endpoint from the regions your users are in, and log failures, not only averages.
2. Latency: judge P95 across regions, not the average
Average latency hides the slow requests your users actually notice. Use P95 latency (the time under which 95% of requests complete) and measure it from more than one region.
In the Chainstack scoring, a mean regional P95 of 80 ms or less scores 100, and 1,500 ms or more scores 0, on a logarithmic scale. Treat any vendor-run benchmark with care: Alchemy, for example, publishes a 14 ms Ethereum P95 from its own four-region test, and that figure comes from the vendor, not an independent party.
Latency matters, but only up to a point. Once providers are within a few milliseconds of each other, users cannot feel the difference, and the gap is often smaller than the variation between regions or between test runs. When the difference is really small, give more weight to the other criteria: cost per request, rate limits, reliability, compliance and support. A provider that is 5 ms faster but costs several times more per request, or throttles you at peak, is rarely the better production choice. For most teams, a cost-effective provider with consistent P95 and high rate limits beats the lowest raw latency.
How to test it: use Chainbench, Chainstack’s open-source RPC benchmarking tool, to test the methods your app uses most, such as eth_call, eth_getLogs, and eth_getBlockByNumber. Run the same workload from each target region and compare P95 and P99 alongside error rates under consistent load.
3. Cost per request: compare real dollars, not credits
Billing units are not comparable. One provider charges one request unit per call, another about 20 API credits, another 10 to 60 compute units depending on the method. Convert everything to dollars per 1M requests, ideally on your own method mix. The table below uses one consistent basis.
| Provider | Billing unit | Entry paid plan, about $49 | Requests included per $49 | Cost per 1M requests* |
|---|---|---|---|---|
| Chainstack | 1 request unit (RU) per request; 2 RUs for archive, debug and trace | Growth, $49 for 20M RUs | 20M | $2.45 |
| Quicknode | About 20 API credits per EVM call; 2× for trace and debug (credit costs) | Build, $49 for 80M credits | About 4M | About $12.25 |
| Alchemy | 10 to 60 compute units per common EVM call (CU costs) | Pay as you go, $0.52 per 1M CUs | About 3.49M | About $14.04 |
*Same basis for all three: list price of a plan around $49 divided by the standard requests it covers, using each vendor's default unit cost for a standard EVM call (1 RU, about 20 credits, 27 CUs per the Alchemy calculator default). Archive, debug and trace calls cost more, and prices at higher volumes differ. Sources: each vendor's pricing page, checked 4 November 2026.
Also check bill predictability: overage rules, multipliers for archive or trace calls, and whether heavy methods cost more. Chainstack plans and request-unit rules are listed on the Chainstack pricing page.
4. Rate limits and throughput: what your plan allows at peak
Rate limits decide whether your app survives a traffic spike. Compare requests per second (RPS) on the plan you would actually buy, and ask what happens when you exceed it.
- Chainstack Growth ($49) includes 250 RPS on EVM chains (50 RPS on Solana mainnet).
- Quicknode Build includes 50 RPS.
- Alchemy includes 300 RPS on its pay-as-you-go plan, and its calculator shows $49 per month for 94.23M CUs, about 3.49M requests at 27 CUs each (Alchemy pricing calculator, throughput docs).
Flat-fee RPS tiers matter if your traffic is steady and high: Chainstack Unlimited Node starts at $149/month, and the comparison lists no self-serve equivalent at Quicknode or Alchemy.
5. Chain and data coverage: networks, archive, trace and streaming
Check that the chains you use today and the ones you will add next year are available as self-serve mainnets. Then check the data you need on them:
- Archive data for historical queries and indexers.
- Debug and trace methods for analytics, MEV and forensics.
- Streaming (WebSockets or gRPC, such as Yellowstone gRPC on Solana) for real-time apps.
- Dedicated nodes for isolation at scale.
Chainstack's supported networks are listed on its protocols page.
On the public data checked here, Quicknode lists 77 self-serve mainnets (Quicknode chains), Alchemy 75 and Chainstack 44. If you need a long-tail chain, coverage may decide the question before price does.
6. Security, compliance and SLA: what procurement will ask
For enterprise and regulated products, verify certifications and the contractual SLA, not marketing claims.
| Item | Chainstack | Quicknode | Alchemy |
|---|---|---|---|
| SOC 2 Type II | Yes (Dec 2025) | Yes | Yes |
| ISO 27001 | Yes (Jul 2026) | Yes | Not disclosed |
| Contractual SLA | 99.9% with credits (Enterprise with paid support) | 99.99% with credits (Enterprise) | Signed SLA, percentage not published |
Quicknode scores highest on enterprise readiness in the comparison (93, against 88 for Chainstack and 48 for Alchemy). Read the SLA for what it measures and what credits you actually receive. Chainstack's certifications are on its security page.
7. Support and developer tooling: response time, MCP and agent payments
Support is rarely the reason you pick a provider, but it is the reason you leave one. Compare declared first-response time by plan:
- Chainstack: under 24 hours, 24×5 on paid plans; under 6 hours, 24×7 with the $100/month Professional add-on.
- Quicknode: 24 hours on Build; 8 hours on Scale (Quicknode pricing).
- Alchemy: 24 hours on pay as you go; 2 to 12 hours on paid Premium tiers (Alchemy support and pricing).
In the Compare scores, Chainstack rates lowest of the three on support. Say so plainly when you evaluate it.
Tooling also matters in 2026 as teams build AI agents. All three providers publish an official MCP server (the Chainstack MCP server: docs search, pricing, status and node creation; Quicknode: 22 tools; Alchemy: 168 tools). Quicknode and Alchemy accept x402 payments for agents that pay per call; Chainstack has not published x402 support.
How to weight the 7 criteria for your use case
Do not use one weighting for every app. Start with the default and adjust. If two providers are within a few milliseconds on P95 latency, treat latency as a tie and let the other criteria decide:
| Use case | Weight up | Why |
|---|---|---|
| Production dApp or wallet | Reliability, cost | Steady traffic, user-facing errors |
| DEX aggregator or trading | Latency, reliability | Stale or slow data loses trades |
| Indexer or analytics | Archive and trace cost, rate limits | Heavy historical reads |
| Enterprise | Cost at scale, compliance, SLA, support | Procurement and audit requirements, plus a bill that stays predictable at billions of requests |
| AI agents | Tooling, cost predictability | Automated, high-volume calls |
Why Chainstack fits enterprise teams that care about cost. At enterprise volumes the bill and the headroom matter more than a few milliseconds. Chainstack combines the lowest cost per request in this comparison, flat-fee RPS through Unlimited Node, Dedicated Nodes, SOC 2 Type II and ISO 27001, and a 99.9% contractual SLA on Enterprise. In the Compare reference scores for the enterprise use case, Chainstack scores 69, against 63 for Quicknode and 45 for Alchemy. Quicknode still leads on enterprise readiness (93 against 88) and on the highest SLA, so teams that need a 99.99% SLA or the widest chain list may choose it instead.
The Compare tool lets you adjust the weights and select your network and use case, so you can see how the ranking changes.
A 5-step process to shortlist and test
- List the chains, methods and monthly request volume you expect.
- Convert each provider's pricing to dollars per 1M requests on that mix.
- Check RPS, archive, trace and SLA on the plan you would actually buy.
- Run a probe from your users' regions for at least 24 hours, logging success rate and P95.
- Re-check pricing pages before you sign, because prices and limits change.
How we built this comparison, and its limits
The figures above come from manually compiled public data for Ethereum mainnet. The reference scores run from 0 to 100, and for a production dApp Chainstack scores 69, Quicknode 56 and Alchemy 47. Those totals cover only 34% to 62% of the weighted pillars, because the reference comparison excludes live reliability and performance data, which the interactive charts add from Grafana observations when available. Quicknode and Alchemy lead on some criteria, including chain coverage, SLA, support and, for Alchemy, throughput around $49/month.
Conclusion: how to choose an RPC provider in 2026
Choose an RPC provider by scoring it on seven criteria: reliability, P95 latency, cost per request, rate limits, chain and data coverage, security and SLA, and support and tooling. Weight them for your use case, then verify the shortlist with your own traffic for at least 24 hours. Latency matters, but when providers are within a few milliseconds of each other, cost, rate limits, reliability and compliance should decide.
On public Ethereum data checked on 4 November 2026, Chainstack has the lowest cost per request, Quicknode has the widest chain list and the highest SLA for Enterprises, and Alchemy has the highest throughput near $49/month. No provider leads on every criterion, so the right choice depends on your chains, traffic and compliance needs. For enterprises that want cost-effective infrastructure with strong compliance, Chainstack is a strong fit.
Prices and limits change, so re-check each vendor's pricing page before you commit.