QuickNode vs Alchemy vs Chainstack: RPC Providers Compared

Last updated: 25 October 2026 · Prices, method costs, limits and benchmark figures rechecked on vendor pages on 25 October 2026

In the QuickNode vs Alchemy vs Chainstack comparison, Chainstack is the best value for most teams, Alchemy is the best developer platform, and QuickNode is the strongest pick for latency on Base, Solana and Arbitrum and for procurement-heavy buyers. We priced four real workloads on each meter to show where every vendor wins.

All three sell the same core product: a remote procedure call (RPC) endpoint backed by synced blockchain nodes. They bill it in three different units, which is why sticker prices mislead. This head to head expands three entries from our ranking of the 12 best RPC node providers, and our methodology page explains how we collect prices and screenshots. For archive-heavy Ethereum work, see our ranking of the best Ethereum RPC providers.

The Decision Kernel

Pick on the shape of your traffic first and the brand second. The three meters reward different method mixes, so the cheapest vendor for a wallet can be the most expensive for an indexer. Count one day of requests by method before you compare any plan. The shortcuts below cover the common cases.

• Lowest bill at almost any volume: Chainstack, sized to a tier that covers your busiest month.
• Token, NFT and transfer APIs on the same key: Alchemy, with its 30M compute unit free tier for prototypes.
• Base, Solana or Arbitrum latency matters most: QuickNode, which led the keyed latency runs on all three chains on 25 October 2026.
• Security questionnaires and DORA reporting: QuickNode states SOC 1, SOC 2 and ISO 27001 and offers DORA reports to enterprise buyers.
• Log-heavy indexing on Ethereum: Chainstack first, QuickNode second. Alchemy charges 60 CU per eth_getLogs call.
• Production with failover: pair any two. Chainstack as primary with Alchemy or QuickNode as backup covers most outages. If you are replacing a single vendor, our guides to Alchemy alternatives and Infura alternatives rank the wider field on the same scorecard.

How We Compared QuickNode, Alchemy and Chainstack

We scored each provider from 1 to 5 on six criteria, weighted them, and doubled the total to get a score out of 10. The weights match our 12-provider ranking, so the scores line up across the site. Every input links to a vendor page or a public benchmark checked on 25 October 2026. Details sit on our methodology page.

• Price per call, 25%: monthly cost for real method mixes, converted from each vendor’s billing unit.
• Reliability, 20%: published uptime terms, support response targets and public latency benchmarks.
• Compliance, 15%: SOC 2, ISO 27001 and other audits stated on the vendor’s own pages.
• Features, 15%: archive data, Trace and Debug methods, streaming, data APIs and dedicated nodes.
• Chain coverage, 15%: chains and networks listed in each vendor’s documentation.
• Free tier, 10%: what a team can run before paying, and for how long.

Criterion (weight)	Chainstack	Alchemy	QuickNode
Price per call (25%)	5	3	3
Reliability (20%)	4	4	4
Compliance (15%)	5	4	5
Features (15%)	4	5	5
Chain coverage (15%)	4	5	4
Free tier (10%)	3	5	2
Score out of 10	8.6	8.3	7.7

QuickNode vs Alchemy vs Chainstack at a Glance

The table lines up the billing unit, free option, entry paid plan, throughput and support target for each provider. Prices are monthly US dollar list prices from each pricing page on 25 October 2026. Annual billing lowers QuickNode by about 30% and Chainstack by 16%, while Alchemy pay as you go has no annual option on its public page.

	QuickNode	Alchemy	Chainstack
Billing unit	API credits, flat per chain	Compute units (CU) per method	Request units (RU), 1 or 2 per call
Free option	One-month trial: 10M credits, 15 rps	Free forever: 30M CU a month, 15 rps	Developer: 3M RU a month, 25 rps
Entry paid plan	Build $49: 80M credits, 50 rps	Pay as you go: $0.525 per 1M CU, 300 rps	Growth $49: 20M RU, 250 rps
Next tiers	$249 (450M), $499 (950M), $999 (2B)	Enterprise, custom	$199 (80M), $499 (200M), from $990 (400M)
Overage per 1M units	$0.62 to $0.50	$0.525 on all usage	$15 to $5
Support target	24h on Build, 12h Accelerate, 8h Scale	48h free, 24h pay as you go	Under 24h on paid plans, 24/5
Chains (vendor figure)	76+ chains, 137 networks	100+ claimed, 89 in API docs	70+

Pricing: Three Different Meters

Each vendor charges for the same eth_call in a different unit. Alchemy weights every method separately, from 10 CU for eth_blockNumber to 60 CU for eth_getLogs. QuickNode charges 20 credits for any standard Ethereum call and 30 on Solana. Chainstack charges 1 request unit for a recent-block call and 2 for archive, Debug or Trace.

Converting each unit to dollars per million calls shows how far apart the three are. The figures below use the entry paid tier with included usage, which is the rate most small teams pay. Chainstack Growth works out to $2.45 per million recent-block calls, about five times cheaper than either rival for a plain eth_call.

Method, per 1M calls	Alchemy PAYG	QuickNode Build	Chainstack Growth
eth_blockNumber	$5.25 (10 CU)	$12.25 (20 credits)	$2.45 (1 RU)
eth_call	$13.65 (26 CU)	$12.25 (20 credits)	$2.45 (1 RU)
eth_getLogs, recent blocks	$31.50 (60 CU)	$12.25 (20 credits)	$2.45 (1 RU)
eth_sendRawTransaction	$21.00 (40 CU)	$12.25 (20 credits)	$2.45 (1 RU)
debug_traceTransaction	$21.00 (40 CU)	$24.50 (40 credits)	$4.90 (2 RU)
Solana getTransaction	$21.00 (40 CU)	$18.38 (30 credits)	$2.45 (1 RU)
Rate above the plan allowance	Same $0.525 per 1M CU	$12.40 per 1M eth_call	$15.00 per 1M recent calls

The last row is the trap. Chainstack’s overage on Growth is $15 per million request units, six times its included rate and higher than QuickNode’s $12.40 per million eth_call. A team that runs 30M recent calls on Growth pays $199, the same as moving up to Pro, which includes 80M.

What Four Real Workloads Cost

Plan tables only matter once you apply them to real traffic. We built four common method mixes, converted each into Alchemy CU, QuickNode credits and Chainstack request units, and picked the cheapest public plan on each vendor. Chainstack came out cheapest in all four, and the gap widens as traffic shifts toward logs and traces.

Workload (monthly)	Alchemy	QuickNode	Chainstack
Wallet backend, Ethereum, 10M requests	$119.18 (227M CU)	$123.40 on Build (200M credits)	$49 on Growth (10M RU)
Tip-following indexer, Ethereum, 50M requests	$1,155.00 (2.2B CU)	$525.50 on Scale (1B credits)	$199 on Pro (50M RU)
Trace-heavy analytics, Ethereum, 20M requests	$441.00 (840M CU)	$333.00 on Accelerate (600M credits)	$199 on Pro (40M RU)
Solana dApp backend, 30M requests	$330.75 (630M CU)	$499 on Scale (900M credits)	$199 on Pro (34.5M RU)

• Wallet backend: 40% eth_getBalance, 20% eth_call, 15% receipts, 15% eth_blockNumber, 5% sends and 5% eth_getLogs. Alchemy averages 22.7 CU per request.
• Indexer: 60% eth_getLogs, 25% eth_getBlockByNumber and 15% receipts, all within 127 blocks of the tip. Alchemy averages 44 CU per request.
• Trace-heavy analytics: 50% debug_traceTransaction, 30% historical eth_getLogs and 20% historical blocks. Every call counts as 2 RU on Chainstack, and traces are 2x credits on QuickNode.
• Solana backend: 50% getAccountInfo, 15% getSignaturesForAddress, 15% getTransaction, 10% sendTransaction and 10% getProgramAccounts, recent slots only. Chainstack bills every getSignaturesForAddress call as archive at 2 RU, even on recent slots, so this mix uses 34.5M RU.

Alchemy and QuickNode trade places by workload. Alchemy wins light reads and Solana, because cheap methods such as getAccountInfo cost 10 CU against QuickNode’s flat 30 credits. QuickNode wins log and trace traffic, where Alchemy’s 60 CU eth_getLogs weight makes the indexer bill 2.2 times larger.

How the Bill Grows at Scale

The cost curve shows what happens as a single Ethereum app grows from 1M to 500M eth_call requests a month. Alchemy and QuickNode rise almost in a straight line because both bill every unit. At 200M calls a month, Chainstack Business costs $499, QuickNode $1,999 and Alchemy $2,730. Chainstack climbs in steps as you move between flat tiers.

Rate limits matter at the top of the curve. 200M calls a month averages 77 requests per second, which fits Chainstack Business at 600 rps and QuickNode Business at 500 rps. Alchemy pay as you go includes 300 rps, which is 10,000 CU per second, and sells extra blocks of 5,000 CU per second for $160 a month each.

Free Tiers and Trials

The free options differ more than the paid ones. Alchemy’s free tier never expires and includes its data APIs. Chainstack’s Developer plan is also free forever and buys the most raw calls, as the table shows. QuickNode offers a one-month trial only, so it cannot host a permanent side project.

Free option	Allowance	Ethereum calls it covers	Limits
Alchemy Free	30M CU a month	About 1.15M eth_call, or 3M eth_blockNumber	15 rps, 5 apps, no Debug or Trace
Chainstack Developer	3M RU a month	3M recent-block calls	25 rps, 1 node, archive from Growth
QuickNode trial	10M credits for one month	500,000 calls	15 rps, ends after the first month

Latency: Why the Benchmarks Disagree

OpenChainBench probes the API-key endpoints of all three vendors every 120 seconds from three regions, and reports two cohorts. Warm runs reuse an open connection, and cold-start runs open a new one for every probe. The two cohorts rank the vendors in opposite order on Ethereum, so the right benchmark depends on how your app connects.

Chain, median (p99)	QuickNode	Chainstack	Leader
Ethereum, warm	55.8 ms (65.2)	7.7 ms (39.3)	Chainstack
Ethereum, cold start	29.7 ms (343.6)	68.1 ms (217.2)	QuickNode
Base, warm	5.3 ms (8.3)	5.7 ms (47.6)	QuickNode
Base, cold start	29.1 ms (123.4)	28.4 ms (130.9)	Chainstack, by 0.7 ms
Solana, warm	3.4 ms (7.6)	6.5 ms (63.7)	QuickNode
Solana, cold start	23.1 ms (322.1)	32.0 ms (242.8)	QuickNode
Arbitrum, warm	5.6 ms (9.4)	6.6 ms (21.6)	QuickNode
Arbitrum, cold start	30.0 ms (367.6)	66.8 ms (154.8)	QuickNode

Long-lived backends with connection pooling see the warm numbers. Serverless functions, edge workers and browser wallets open fresh connections and see the cold-start numbers. QuickNode’s warm tail on Base and Solana stays under 10 ms at p99, the tightest result in the table.

Alchemy did not appear in either keyed cohort on 25 October 2026, so we have no same-day figure to compare. Our 12-provider ranking recorded 9 ms for Alchemy on the Ethereum keyed run a day earlier. These figures move daily, so treat them as a shortlist filter and run your own test.

Security, Compliance and SLAs

All three vendors state a SOC 2 Type II report, so the differences sit in the extra audits and in who gets a contractual SLA. QuickNode states the widest audit set, with SOC 1 Type 2, SOC 2 Type 2 and ISO 27001. At all three vendors, contractual uptime SLAs come with enterprise contracts.

	QuickNode	Alchemy	Chainstack
Audits stated	SOC 1 Type 2, SOC 2 Type 2, ISO 27001	SOC 2 Type II	SOC 2 Type II, ISO 27001
Uptime language	99.99% uptime on the security page	Signed SLAs on Enterprise	99.99%+ claim, SLA on Enterprise
Paid support response	24h Build, 12h Accelerate, 8h Scale	24h pay as you go, premium 12h, 4h or 2h	Under 24h standard, under 6h for $1,000 a year, under 1h for $10,000 a year
Regulatory extras	DORA reports for enterprise	Not stated	Not stated

Features and Chain Coverage

Alchemy is the broadest developer platform, with token, NFT, transfer and webhook APIs on the same key. QuickNode sells a similar add-on catalog and includes archive data on every plan. Chainstack is the only one of the three that publishes self-serve dedicated node pricing. Chain counts below come from each vendor’s own documentation.

Feature	QuickNode	Alchemy	Chainstack
Archive data	All plans	All plans, including Free	Growth and above
Debug and Trace	Build and above, 2x credits	Paid plans, 40 CU per trace	Paid plans, 2 RU per call
Data APIs	Token, NFT and add-on marketplace	Token, NFT, transfers, webhooks	Few data APIs, add-ons such as MEV protection and Warp transactions
Dedicated nodes	Enterprise	Enterprise	Pro and above: $199 plus from $0.50 an hour compute
Solana extras	Solana gRPC add-on and Streams	Solana gRPC from $75 per TB	Yellowstone Geyser gRPC add-on, Trader Nodes until 1 December 2026
Chains	76+ chains, 137 networks	100+ claimed, 89 in API docs	70+

Alchemy’s marketing says 100+ chains, while its chain API overview listed 89 when we checked. Chainstack’s documentation states that it plans to deprecate Trader Nodes on 1 December 2026, so Solana trading teams on that product should plan a move to Global Nodes. Our dedicated nodes coverage explains when a private node pays off.

QuickNode

QuickNode is a multi-chain RPC platform billed in API credits. Every standard Ethereum call costs 20 credits and every Solana call 30, which makes bills easy to forecast. Build costs $49 a month, or $34 billed annually, for 80M credits and 50 requests per second. Trace and Debug start on Build.

• Plans: Build $49 (80M credits), Accelerate $249 (450M), Scale $499 (950M), Business $999 (2B). Annual billing saves about 30%.
• Overage: $0.62 per 1M credits on Build, falling to $0.50 on Business.
• Strengths: lowest warm latency on Base, Solana and Arbitrum on 25 October 2026, SOC 1 and SOC 2 Type 2, ISO 27001, archive data on every plan.
• Weaknesses: no free-forever tier, and Solana calls cost 30 credits, which lifts Solana bills above Alchemy’s.

Alchemy

Alchemy combines RPC access with a large set of data APIs, webhooks and SDKs, billed in compute units that vary by method. The free tier gives 30M CU a month with no time limit. Pay as you go charges $0.525 per 1M CU from the first unit, with 300 requests per second included. Larger teams move to Enterprise for signed SLAs.

• Plans: Free (30M CU, 15 rps, 5 apps), Pay as you go ($0.525 per 1M CU, 300 rps, 30 apps), Enterprise (custom).
• Method weights: 10 CU for eth_blockNumber, 26 for eth_call, 40 for sends and traces, 60 for eth_getLogs.
• Strengths: most useful free tier, data APIs and webhooks, widest chain list, cheap light reads on Solana.
• Weaknesses: log-heavy and trace-heavy workloads cost the most of the three, and contractual SLAs need Enterprise.

Chainstack

Chainstack runs Global Nodes and dedicated nodes across 70+ chains, billed in request units. A recent-block call costs 1 RU, and archive, Debug and Trace calls cost 2 RU. Growth costs $49 a month for 20M request units and 250 requests per second. Archive data starts on Growth and dedicated nodes on Pro.

• Plans: Developer free (3M RU), Growth $49 (20M), Pro $199 (80M), Business $499 (200M), Enterprise from $990 (400M). Annual billing saves 16%.
• Overage: $20 per 1M RU on Developer, $15 on Growth, $12.50 on Pro, $10 on Business and $5 on Enterprise.
• Strengths: lowest bill in all four workloads, flat meter for logs, SOC 2 Type II and ISO 27001, published dedicated node pricing.
• Weaknesses: high overage on lower tiers, slower cold-start latency on Ethereum and Arbitrum, fewer data APIs.

Final Ranking

Chainstack takes first place on price, audits and a flat meter that suits logs and traces. Alchemy is second on the strength of its free tier, data APIs and chain coverage. QuickNode is third on our weights, mostly because it has no free tier and costs more per call, and it still wins on latency for three of four chains.

1. Chainstack, 8.6: best value and the default primary endpoint for most teams.
2. Alchemy, 8.3: best developer platform and free tier, strongest for wallets and data-heavy apps.
3. QuickNode, 7.7: best latency on Base, Solana and Arbitrum, widest audit set for regulated buyers.

How to Run a One-Week Bake-Off

A week of side-by-side traffic answers the questions a pricing page cannot. Send the same requests to all three endpoints from the region where your servers run. Log median and tail latency, error rates and the block number each endpoint returns, then price that week’s method mix on each meter.

for url in "$QN_URL" "$ALCHEMY_URL" "$CHAINSTACK_URL"; do
  curl -s -o /dev/null -w "%{time_total}\n" \
    -H "Content-Type: application/json" \
    -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' \
    "$url"
done

Run the loop from a long-lived server and from a serverless function to see both warm and cold behavior. Use each vendor’s free tier or trial for the test. Read the full RPC providers hub for more head to head comparisons.

Frequently Asked Questions