Providers: GetBlock, Alchemy, QuickNode, Infura, Chainstack, dRPC
Checked: 2026-09-15 (primary public sources only)
Currency: USD unless the provider states otherwise
Scope: Public shared RPC/API pricing, plus whether a dedicated-node and enterprise path is publicly offered. Taxes, negotiated discounts, chain-specific exceptions, add-ons, and temporary promotions are excluded unless noted.
Executive takeaway
There is no defensible cross-provider “price per million” winner from the public cards alone. Each vendor meters a different object—GetBlock Compute Units, Alchemy Compute Units, QuickNode API Credits, Infura credits, Chainstack Request Units, and dRPC requests plus Compute Units—and the method weights are not standardized. A million units at one provider is not a million identical RPC calls at another.
For an actual buying decision, replay the same 7–30 day method mix against every provider’s current weight table/calculator, add required archive and add-on usage, then test p95/p99 latency and throttling in the needed regions.
Matrix A — entry pricing, included usage, overages, throughput
| Provider | Free tier | Cheapest public paid plan | Included usage on that paid plan (native units/cadence) | Overage / additional usage | Throughput limit on cheapest paid plan |
|---|---|---|---|---|---|
| GetBlock | Free, $0 indefinitely: 50,000 CU/day, 20 RPS, 2 access tokens; no extra-CU purchase | Starter: $49/mo, or $39/mo billed annually | 90M Compute Units/month | Extra CU packages are available on demand, but the Starter package price is Not publicly verified. Public unit overages begin at Pro: $0.40/additional 1M CU; Premium: $0.35/additional 1M CU | 250 requests/sec |
| Alchemy | Free, $0: 30M CU/month; live page shows 500 CU/s (25 RPS) | Pay As You Go: $0.525 per 1M CU; no fixed monthly commitment shown | No included paid bundle; usage is metered from the first paid CU | $0.525 per 1M CU. Additional capacity: $160/mo per 5,000 CU/s block | 10,000 CU/s (~300 RPS) included; self-serve capacity up to 30,000 CU/s |
| QuickNode | One-month free trial, not an indefinite free tier: 10M API Credits, no overage, no card; 15 RPS | Build: $49/mo month-to-month, or $34/mo billed annually (30% discount displayed) | 80M API Credits/month | $0.62 per additional 1M API Credits | 50 RPS |
| Infura | Free, $0: pricing table shows 3M credits/day, 500 credits/sec | Developer: $50/mo | 15M credits/day | Optional 55M additional credits for $200/month. A simple per-unit overage rate is Not publicly verified. | 4,000 credits/sec (not requests/sec) |
| Chainstack | Developer, $0: 3M Request Units/month, 25 RPS | Growth: $49/mo, or $40/mo billed annually | 20M Request Units/month | $15 per extra 1M Request Units on Growth | 250 RPS |
| dRPC | Free, $0: 210M CU/month, 100 RPS | Growth PAYG: $6 per 1M requests; the card also shows 20M Compute Units | No fixed monthly bundle/commitment shown; billed by usage | No monthly limits, overage fees, or request expiration; automatic volume discounts apply. dRPC documents a flat 20 CU for billed RPC methods (with listed zero-CU exceptions), reconciling 1M requests with 20M CU | 5,000 RPS |
Matrix B — archive, dedicated infrastructure, enterprise, evidence
| Provider | Archive access | Dedicated-node option | Enterprise availability | Evidence status | Primary source URL | Checked date |
|---|---|---|---|---|---|---|
| GetBlock | Yes on selected networks from Starter; limited on Free | Yes: private dedicated nodes from $1,000/mo with a public configurator. Separate fixed-RPS “Limitless Node” starts at $150/mo | Yes, from $999/mo, then custom | Verified — live primary pricing page and machine-readable pricing reference. GetBlock’s pricing reference says it was last updated 2026-08-19 | https://getblock.io/pricing/ ; https://getblock.io/pricing.md | 2026-09-15 |
| Alchemy | Yes; archival data is listed in Core RPC and metered in CUs | Yes: Dedicated Clusters, contact sales; public price is Not publicly verified. | Yes, contact sales/custom; current page starts Enterprise at 1,000 RPS | Partial due to a first-party Free-throughput conflict: live pricing shows 500 CU/s, while pricing-plan documentation says 300 CU/s. Public paid plan and Dedicated Cluster availability are verified | https://www.alchemy.com/pricing ; https://www.alchemy.com/docs/reference/pricing-plans ; https://www.alchemy.com/dedicated-clusters | 2026-09-15 |
| QuickNode | Yes; the live comparison table marks archive data available on all displayed plans, including trial | Yes: Dedicated Clusters / dedicated backends; enterprise/contact sales, public price Not publicly verified. | Yes, contact sales/custom | Verified — live primary pricing page. | https://www.quicknode.com/pricing | 2026-09-15 |
| Infura | Yes; Core RPC includes full archive data | Not publicly verified. The reviewed public pricing page does not offer a dedicated blockchain-node SKU | Yes: Team and Enterprise/contact sales | Primary-source conflict. The plan table shows Free at 3M credits/day and 500 credits/sec, while FAQ copy on the same page says 6M/day and 2,000 credits/sec. This report uses the explicit plan-table values and flags the discrepancy | https://www.infura.io/pricing | 2026-09-15 |
| Chainstack | Growth explicitly includes archive data; Free archive access is Not publicly verified. | Yes: a public dedicated-node configurator is available from Pro. Total price is configuration-specific; a universal all-in starting price is Not publicly verified. | Yes: Enterprise from $990/mo, with custom options | Verified for plan cards and availability of configurable dedicated nodes; exact dedicated total varies by chain, mode, compute, and storage. | https://chainstack.com/pricing/ | 2026-09-15 |
| dRPC | Yes; archive requests are priced the same as full-node requests | Not publicly verified. No dedicated-node SKU or price was verified on the reviewed primary pricing/docs pages | Yes: Enterprise for 300M+ requests/month, custom pricing and unlimited RPS | Verified for public pricing and request/CU conversion. Dedicated infrastructure remains not publicly verified | https://drpc.org/pricing ; https://drpc.org/docs/pricing/compute-units | 2026-09-15 |
Why the usage units cannot be compared directly
| Provider | Native metering unit | What changes the bill |
|---|---|---|
| GetBlock | Compute Units (CU) | A weight per RPC method based on serving cost; heavy methods consume more CUs than simple lookups |
| Alchemy | Compute Units (CU) | Method-specific CU weights; separate products/capacity can add charges |
| QuickNode | API Credits | Requests × method/chain credit multiplier; the pricing calculator exposes different credits per request |
| Infura | Credits | Method-specific credit costs; throughput is also stated in credits/sec, not RPS |
| Chainstack | Request Units (RU) | RPC calls are weighted; add-ons and dedicated-node compute/storage are separate |
| dRPC | Requests and Compute Units | dRPC documents a flat 20 CU for billed RPC methods across supported chains, with listed zero-CU exceptions; archive is priced the same as full-node requests |
Consequences:
- $0.40/M CU is not automatically cheaper than $0.50/M credits. The denominator is vendor-defined.
- RPS and credits/sec are not interchangeable. If one call costs multiple credits, credits/sec supports fewer actual requests/sec.
- Archive “included” does not mean archive-heavy workloads cost the same. Heavy methods may consume more weighted units even when no separate archive surcharge exists.
- Daily and monthly allowances behave differently. A daily reset can strand unused capacity and limit burst absorption; a monthly pool is more flexible.
- Annual effective prices require commitment. They should not be compared against another vendor’s month-to-month price without noting that commitment.
Buyer recommendations
1) Small workloads — prototypes, testnets, low-volume apps
Shortlist: Alchemy, Chainstack, GetBlock, dRPC; use QuickNode only if a one-month trial is enough.
- Alchemy offers a straightforward perpetual free pool with broad developer tooling, but confirm the Free throughput because its live page and pricing documentation disagree.
- Chainstack is easy to reason about for small workloads because its free plan is monthly RU-based and its first paid tier has explicit extra-RU pricing.
- GetBlock is attractive when 20 RPS and a daily CU reset fit the workload, especially when the buyer values a direct path to publicly priced dedicated infrastructure.
- dRPC advertises the largest headline free allowance and 100 RPS; its docs make the request/CU conversion unusually explicit, but chain, region, and service behavior still need validation.
- QuickNode’s $0 offer is a one-month trial, not a durable free tier.
Decision rule: choose based on chain coverage, SDK/tooling, region, and whether the free allowance survives a replay of your real RPC methods—not the largest headline “M.”
2) Growth workloads — production apps with variable traffic
Best public-package fit: GetBlock Starter/Growth, Chainstack Growth/Pro, or dRPC Growth; include Alchemy PAYG when elasticity matters more than a fixed bundle.
- GetBlock Starter combines 90M CU/month with 250 RPS and paid-plan rollover, but buyers need a public Starter–Scale top-up price to model spikes precisely.
- Chainstack Growth gives 250 RPS and an explicit $15/1M-RU extra-usage rate, improving cost predictability.
- dRPC Growth publishes 5,000 RPS and metered pricing with no monthly limit, making it a strong bursty-traffic candidate after chain coverage and load testing.
- Alchemy PAYG avoids a package cliff and includes 300 RPS, but capacity add-ons and method weights must be included in the model.
- QuickNode Build has a lower 50-RPS ceiling, so growth buyers should check whether Accelerate or a capacity add-on is required before comparing cost.
- Infura Developer offers high credit throughput, but the pricing page’s Free-tier contradiction is a signal to confirm all limits in writing before purchase.
Decision rule: model three scenarios—baseline, 2× burst month, and archive-heavy month—and reject any option whose public page cannot produce a bounded bill.
3) High-volume workloads — exchanges, wallets, trading, indexing, fintech
Shortlist: GetBlock Pro/Premium/Enterprise, dRPC Enterprise, QuickNode Business/Enterprise, Chainstack Business/Enterprise, and Alchemy Enterprise/Dedicated Clusters. Do not choose from the cheapest-paid rows above.
- GetBlock is strongest on public packaging transparency: 1B CU at Pro, 1.6B CU at Premium, explicit Pro/Premium overages, Enterprise from $999, Limitless from $150, and dedicated nodes from $1,000.
- dRPC is compelling for geographically distributed, very bursty traffic because Enterprise advertises unlimited RPS, but architectural fit and provider-network consistency need load testing.
- QuickNode and Alchemy should be evaluated where mature platform tooling and dedicated clusters matter; both require sales contact for dedicated pricing.
- Chainstack provides a public dedicated-node configurator and explicit shared-plan overages, which helps early TCO modeling; the all-in dedicated total depends on compute and storage.
- Infura remains relevant for Ethereum-centric stacks, but resolve the live pricing-page contradictions and obtain dedicated/enterprise terms in writing.
Decision rule: run a 7–30 day mirrored workload and compare (a) weighted unit consumption, (b) p95/p99 latency by region, (c) rate-limit behavior, (d) archive/trace performance, (e) SLA remedies, and (f) all-in cost including add-ons and support.
Three concrete GetBlock pricing/packaging opportunities
1) Publish Starter–Scale top-up prices and a bill calculator
Today those plans say “extra CU packages on demand,” while Pro/Premium expose per-1M-CU overages. Publish fixed top-up blocks and automatic overage rates for every paid shared tier, with spend caps and alerts. Show the exact crossover where upgrading is cheaper than buying more CUs.
Why it matters: Chainstack, QuickNode, Alchemy, and dRPC expose a calculable marginal-usage path. GetBlock’s missing entry-tier top-up price makes a growth-stage bill harder to approve even when the base bundle is attractive.
2) Add a low-commitment elastic plan that separates usage from burst capacity
Introduce a Flex package with a small or zero monthly commitment, public per-1M-CU pricing, and purchasable RPS bands (for example 250/500/1,000 RPS), plus a hard monthly spend cap. Keep existing bundles for buyers who prefer committed discounts.
Why it matters: Alchemy and dRPC make metered entry easy, while GetBlock forces a bundle choice. Separating units from RPS would better serve low-volume but bursty wallets, trading agents, launch events, and webhook/indexing workloads.
3) Package shared + isolated capacity as one production-resilience offer
Create a public Production Resilience bundle combining a shared Pro/Premium pool with one Limitless or dedicated failover endpoint, one SLA, one dashboard, and a documented failover policy. Price 2–3 reference configurations directly on the pricing page and link the live dedicated configurator.
Why it matters: GetBlock already has an unusually transparent ladder—shared, Limitless, dedicated—but buyers must assemble resilience themselves. A bundled active/standby or overflow package would turn that infrastructure breadth into a clearer enterprise buying advantage over providers whose dedicated pricing is sales-only.
Evidence caveats and validation checklist
- All facts above were checked against public first-party pages on 2026-09-15. “Not publicly verified” means the reviewed primary sources did not substantiate the field; it does not prove the capability is absent.
- Dynamic pricing pages can change without notice. Re-check before procurement or publication.
- Alchemy’s live pricing page shows 500 CU/s for Free, while its pricing-plan documentation says 300 CU/s; use the live value here but confirm before relying on it operationally.
- Infura’s internal page contradiction should be resolved with sales/support and contract language.
- dRPC’s docs reconcile its request/CU labels at 20 CU per billed RPC method, with listed zero-CU exceptions; still confirm the current table before procurement.
- For dedicated nodes, request a configuration-specific quote including region, client, archive depth, storage, egress, failover, support, and term.
Primary sources
- GetBlock pricing: https://getblock.io/pricing/
- GetBlock machine-readable pricing reference: https://getblock.io/pricing.md
- Alchemy pricing: https://www.alchemy.com/pricing
- Alchemy pricing-plan documentation: https://www.alchemy.com/docs/reference/pricing-plans
- Alchemy Dedicated Clusters: https://www.alchemy.com/dedicated-clusters
- QuickNode pricing: https://www.quicknode.com/pricing
- Infura pricing: https://www.infura.io/pricing
- Chainstack pricing: https://chainstack.com/pricing/
- dRPC pricing: https://drpc.org/pricing
- dRPC Compute Units documentation: https://drpc.org/docs/pricing/compute-units