Solana RPC pricing in 2026: 5 main billing systems deciphered

A $49 Solana RPC plan from one provider is not equivalent to a $49 plan from another. Helius uses credits, QuickNode—API Credits, Alchemy operates method-weighted Compute Units, Chainstack—Request Units, and RPC Fast combines Compute Units with plan-level limits.

That makes headline prices poor predictors of your actual Solana RPC cost. The useful comparison is: take the same workload, apply each provider's documented billing rules, find the lowest plan that supports it, then calculate the monthly bill.

This comparison does exactly that for five providers and three workloads. Prices and billing rules were checked on August 7, 2026. Monthly list pricing is used; annual discounts and temporary promotions are excluded.

TL;DR

• 1M billing units rarely means 1M requests. A standard Solana request costs 1 CU on RPC Fast, 1 credit on Helius, 30 API Credits on QuickNode, and 10–20+ CU for many common Alchemy methods. Chainstack generally bills a current-state Solana request at 1 RU.
• A sustained 10 RPS bot sends 25.92M requests/month. Under the workload defined below, the calculated bills range from $114.60 to $432.46/month.
• Streaming changes the economics again. For our 500 GB/month Yellowstone scenario, calculated public pricing ranges from $84.16 to $499/month because some providers meter bytes while others bundle streams into plans.
• getProgramAccounts exposes the biggest pricing-model difference. 2.592M calls/month becomes 25.92M RPC Fast CU, 25.92M Helius credits, 77.76M QuickNode credits, 51.84M Alchemy CU, or 2.592M Chainstack RU.
• Dedicated infrastructure starts making economic sense only after you compare the full SaaS bill, not the base plan price.

Solana RPC pricing compared: What the plans really include

If you search for free Solana RPC, quota size alone is misleading. Method weights, RPS ceilings, stream billing, and product gates all determine how far the free allocation goes.

RPC Fast currently displays promotional $36/$199/$399 prices beside its $45/$249/$499 monthly list prices. We use the list prices below so a temporary campaign does not distort the comparison. 

Why 1 million credits does not mean 1 million Solana requests

Take the exact same getProgramAccounts call:

These numbers are not equivalent currencies. Each provider prices its unit differently and attaches different plan restrictions to the method. That is why comparing "$ per million credits" produces the wrong answer.

Helius also offers getProgramAccountsV2 at 1 credit, but that is a separate paginated API. The calculations below deliberately use the standard Solana getProgramAccounts method so the workload stays identical.

What you actually pay: three Solana workloads

Calculation methodology

Every scenario uses:

• 30 days = 2,592,000 seconds.
• Mainnet.
• Traffic runs continuously unless stated otherwise.
• Monthly list prices.
• The cheapest public self-service plan that satisfies method access, RPS, and stream requirements.
• Published overage rates where applicable.
• No enterprise discount.
• No Solana base fees, priority fees, Jito tips, or sender-specific transaction charges.

For Alchemy PAYG, we do not subtract the 30M-CU free allowance. Free and PAYG are separate plans in the pricing table.

Scenario 1: Simple Solana bot at sustained 10 RPS

10 RPS × 2,592,000 seconds = 25.92M requests/month.

Assume:

• 40% getLatestBlockhash
• 30% getSignatureStatuses
• 10% simulateTransaction
• 10% sendTransaction
• 10% getBalance

The result is specific to this method mix. Change getBalance to getLargestAccounts, increase simulation frequency, or move reads into a stream, and the ranking changes.

Scenario 2: Sniper with Yellowstone gRPC

Assume:

• 2 continuous mainnet Yellowstone streams
• 500 GB delivered/month
• Supporting JSON-RPC at 2 RPS
• Supporting calls split 50/50 between getLatestBlockhash and getSignatureStatuses

Supporting RPC traffic equals 5.184M calls/month. For bandwidth-priced services, 500 GB is treated as 0.5 TB / 500,000 MB.

This comparison is about billing, not stream performance. Filter support, slot freshness, replay, geographic locality, transaction coverage, and p95/p99 delivery still need benchmarking against your strategy.

Scenario 3: Dashboard polling getProgramAccounts once per second

1 request/s × 2,592,000 seconds = 2.592M getProgramAccounts calls/month.

This polling pattern is often worth replacing with streaming plus a local state cache. We model it because it exposes the cost of heavy-method billing.

The operational lesson is more important than the ranking: broad polling makes both your bill and node load scale with polling frequency. For live state, stream once, maintain local state, and reserve getProgramAccounts for initialization or reconciliation where the application architecture permits it.

The costs headline pricing does not show

Five items deserve attention before choosing a provider:

• Method weighting. One HTTP request is not one billing unit.
• RPS limits. A large monthly allowance is useless if your workload exceeds the plan's real-time ceiling.
• Stream bytes. With metered gRPC or WebSocket products, broader filters directly increase spend.
• Product gates. Mainnet Yellowstone, heavy methods, and archive access often start above the cheapest paid tier.
• Overage economics. The cheapest base plan is not always the cheapest plan after sustained traffic.

For production bots, add one more metric: cost per successfully landed transaction, not cost per RPC request. RPC spend, priority fees, tips, failed simulations, expired blockhashes, and retry storms affect different parts of that number.

When SaaS RPC becomes more expensive than a dedicated Solana node

There is no universal request count where dedicated infrastructure wins. Hardware requirements change with indexing, plugins, geography, HA design, and method profile.

RPC Fast does provide enough public pricing to calculate two useful break-even points.

Its Aperture SaaS plan lists $499/month with 120M CU and $5 per additional 1M CU. A Light dedicated node starts at $2,200/month, excludes heavy methods, and includes 512 GB RAM.

For ordinary 1-CU RPC traffic:

• $499 + (X − 120M) × $5/M = $2,200
• X = 460.2M CU/month, or about 177.5 sustained RPS.

For getProgramAccounts, Light is not a valid comparison because it excludes the method. Medium supports getProgramAccounts and starts at $2,700/month.

• $499 + (X − 120M) × $5/M = $2,700
• X = 560.2M CU = 56.02M getProgramAccounts calls/month, or about 21.6 sustained calls/s.

These are list-price break-even calculations, not migration thresholds. Dedicated infrastructure also changes isolation, tuning, plugin access, operational responsibility, latency variance, and failure design.

Which Solana RPC pricing model fits your workload?

Helius is worth evaluating when Solana-specific APIs, LaserStream, Sender, or Shred Delivery matter alongside RPC. QuickNode fits teams standardizing infrastructure across many chains and offers a separate flat-rate RPS model. Alchemy's PAYG and per-TB gRPC model fits workloads where consumption maps cleanly to usage. Chainstack keeps standard Solana request accounting simple and sells Yellowstone as a fixed add-on. RPC Fast packages Yellowstone into Stream and adds Aperture, Shredstream, Beam, and a direct path to managed dedicated infrastructure at higher tiers.

The cheapest option changes with method mix, RPS, stream volume, and architecture.

Final recommendation: Price your workload, not the plan card

Solana RPC pricing becomes understandable once you reduce it to four inputs:

Run that calculation before comparing $49, $249, or $499 plan cards. Then benchmark latency, freshness, failure rate, and transaction landing on the providers that survive the cost filter.