Compare Solana RPC providers¶
There is no cheapest Solana RPC provider — there is a cheapest one for your method mix. Across the seven providers here, a standard account read spans 3.3× ($4.50 to $15.00 per million). A history read spans 8.3× ($6.00 to $50.00). And the ranking genuinely inverts: QuickNode is the most expensive standard read on this page and charges no premium whatsoever for history.
Within a single provider the swing is larger still. Helius charges $5.00 per million standard reads
and $50.00 for the same volume of getBlock — a flat 10×.
So the useful question is not "who is best?" but "what does my workload call?"
Why you can trust these numbers
RPC Plane sells no RPC capacity and takes no affiliate revenue from any provider on this page.
Every figure is sourced from the vendor's own published pricing, dated, and kept in a public
dataset at pricing.rpcplane.dev you can diff against.
The short answer, by workload¶
| If your traffic is mostly… | Cheapest | At | Runner-up |
|---|---|---|---|
Account and state reads (getAccountInfo, getBalance) |
Alchemy | $4.50/M | Helius, $5.00/M |
History (getBlock, getTransaction, getSignaturesForAddress) |
dRPC | $6.00/M | OnFinality, $7.50/M |
getProgramAccounts |
dRPC | $6.00/M | OnFinality, $7.50/M |
DAS / Metaplex (getAsset*, searchAssets) |
QuickNode | $30.00/M | Helius and Triton One, $50/M |
Writes (sendTransaction) |
Helius | $5.00/M | dRPC, $6.00/M |
| Nothing in particular / just starting | Alchemy | free | 30M CU/month, no card |
Four different providers win a row, and no provider appears in every one. That is the whole finding.
Cost per million calls¶
Pay-as-you-go and overage rates — the per-call price once an included quota is spent. Subscription tier sizes are not modelled here; see provider pricing for the credit and compute-unit weights these are derived from.
| Provider | Model | Standard read | History read | getProgramAccounts |
DAS | Write |
|---|---|---|---|---|---|---|
| Alchemy | compute units, $0.45/M CU | $4.50 | $18.00 | $9.00 | — | $9.00 |
| Helius | credits, $5.00/M | $5.00 | $50.00 | $50.00 | $50.00 | $5.00 |
| dRPC | flat 20 CU/call, $0.30/M CU | $6.00 | $6.00 | $6.00 | — | $6.00 |
| OnFinality | 2 RU/call, $3.75/M RU | $7.50 | $7.50 | $7.50 | — | ⁽²⁾ |
| Chainstack | request units, $10.00/M RU | $10.00 | $10.00–$20.00 ⁽³⁾ | $10.00 | — | $10.00 |
| Triton One | $10/M + $0.08/GB | $10.00 | ~$50 ⁽¹⁾ | $10.00 | $50.00 | $10.00 |
| QuickNode | credits, $0.50/M | $15.00 | $15.00 | $15.00 | $30.00 | $15.00 |
Standard read = getAccountInfo. History = getBlock / getTransaction.
⁽¹⁾ Triton bills bandwidth separately; a getBlock response of ~500 KB adds roughly $40/M on top of
the $10 call charge. For small responses the bandwidth component rounds to nothing.
⁽²⁾ sendTransaction is not in OnFinality's published Solana method table. Confirm write support
before routing writes there.
⁽³⁾ Chainstack bills history at 1 RU near the chain tip and 2 RU only below firstAvailable + 5,000
— so live indexing pays $10.00/M and backfill pays $20.00/M. Details in
provider pricing.
Rates are each provider's best published non-enterprise rate — the best price reachable without a custom contract, which is the rule the pricing dataset behind this page states. No provider is quoted at an enterprise discount its neighbours aren't getting. All verified 2026-09-06 against published pricing.
What that table actually says¶
dRPC's flat rate is the most consequential number on this page. Every method costs 20 compute
units at $0.30/M CU — $6.00 per million calls, whether that call is getAccountInfo or getBlock.
Nothing else here prices history that low, and the gap is not marginal: Helius charges 8.3× more for
the same getBlock.
| dRPC becomes cheaper than… | Above this share of history calls |
|---|---|
| Helius | 2.2% |
| Alchemy | 11.1% |
| OnFinality, Chainstack, Triton One, QuickNode | always |
The Helius row is the striking one. Two history calls in every hundred is enough to flip the answer, and essentially any real Solana workload clears that — a wallet rendering transaction history clears it, an indexer clears it many times over.
What dRPC does not do is DAS. There is no Metaplex asset API on it, so NFT and compressed-asset workloads cannot use it at all. That is the reason it does not simply win this page outright.
QuickNode looks expensive and is, until history dominates. At $15/M it is the priciest standard read here — 3.3× Alchemy. It charges no premium for history, which most providers do, so the more history you call the better it looks. Where that actually pays off, blending standard reads and history:
| QuickNode becomes cheaper than… | Above this share of history calls |
|---|---|
| Triton One | 12.5% |
| Helius | 22.2% |
| Chainstack | 50.0% |
| Alchemy | 77.8% |
| dRPC, OnFinality | never |
The Alchemy row is the one that matters. "QuickNode is cheapest for history" is true per method and misleading in aggregate — unless more than three quarters of your calls are history reads, Alchemy's $4.50 standard rate more than absorbs its 4× history premium. Dedicated indexers clear that bar. Almost nothing else does.
Helius is cheap until it isn't. $5/M standard is competitive, and writes at $5/M are the best
here. But archival, DAS and getProgramAccounts are all 10 credits — a flat 10× — so a
history-heavy or NFT workload pays $50/M. This is the single most common way a Solana RPC bill
comes in higher than expected.
Alchemy wins almost every blend that isn't history-heavy. Cheapest standard read, and a 4× history premium mild enough that it stays ahead of QuickNode until history passes 78% of traffic — though dRPC overtakes it at 11%. The gap is DAS: there is no documented Solana DAS pricing, so an NFT-heavy workload cannot be costed on Alchemy at all.
Triton One is flat, and then bandwidth happens. One price for nearly everything, which is
genuinely simple — until you call getBlock at scale and the $0.08/GB line becomes the bill.
Chainstack is the provider to read the tier ladder on. Its RU price runs from $20.00/M on the
free Developer plan down to $5.00/M on Enterprise at $990/month — a 4× spread, wider than anyone
else's here, so where you land on that ladder matters more than for any other provider on this page.
Its real edge is the archive definition: history near the chain tip bills at the standard 1 RU, so a
live indexer never pays the archive multiplier at all. Only backfill below firstAvailable + 5,000
does, and no one else here draws that line.
Free tiers compared¶
| Provider | Free allowance | In calls | Rate limit | Renews? |
|---|---|---|---|---|
| dRPC | 210M CU / 30 days | ~10.5M | — | Every 30 days — public node pool only |
| OnFinality | 400K RU/day | ~200K/day (~6M/mo) | 40 RU/s | Daily |
| Alchemy | 30M compute units/month | ~3M standard reads | 25 req/s | Monthly |
| Chainstack | 3M RU/month | 3M | 25 req/s | Monthly |
| QuickNode | 10M credits | ~333K standard reads | 15 req/s | No — one-time trial |
| Helius | 1M credits/month | 1M | 10 req/s | Monthly |
| Triton One | None | — | — | $125 prepaid, non-refundable |
dRPC's is the largest on paper by roughly 3× — but it is served over dRPC's public node pool, which is slower and less reliable than its paid endpoints, so it belongs in a failover leg rather than in front of production traffic. Among free tiers on dedicated infrastructure, Alchemy's is the largest: about 3M standard reads a month against Helius's 1M.
The catch on Helius's free tier is not the credits, it's the 1 sendTransaction per second. Any
application that writes will hit that long before it runs out of credits.
You do not have to pick one. See free-tier maxxing for stacking them at $0/month.
What the price tables don't tell you¶
Rate limits are a separate ceiling. Alchemy's free tier is 25 req/s and its paid plan starts at 300; Helius runs 10 / 50 / 200 / 500 by tier. You can be nowhere near a spend limit and still be throttled.
And the headline rate limit is not the binding one. Helius publishes a separate, much tighter
cap per method category — the free tier is 10 req/s overall but 1 sendTransaction/s, 2 DAS/s
and 5 getProgramAccounts/s, and the same shape holds on paid tiers. The public Solana endpoint
allows ~10 req/s but only 4/s for any single method. If your traffic is concentrated on one call,
that sub-limit is your real ceiling, and comparing headline numbers across providers will mislead
you. See working around a per-method limit.
Entry price varies more than per-call price. Helius Developer, QuickNode Build, Chainstack Growth and OnFinality Growth are all $49/month — a striking convergence. Alchemy has no minimum at all: pay-as-you-go from the first call. Triton wants $125 prepaid in stablecoins, non-refundable, valid 12 months, which makes it the only one here you cannot evaluate for free.
The rates above are not the rates you get on day one. They are each provider's best non-enterprise price, and reaching it means committing to a mid or upper tier — Chainstack's $10.00/M is the $499 Business plan, not the $49 Growth plan, which bills $15.00/M. Read each provider's ladder in provider pricing against the volume you actually expect. A comparison that quotes one provider's enterprise rate against another's entry rate will invert the ranking outright, which is exactly what this page did for Chainstack until 2026-09-06.
"No premium for history" is a policy, not a law. The flat rates at dRPC and QuickNode are the reason to pick either for indexing work, and they are also the thing most likely to change — dRPC's own flat rate is only as old as June 2025, and replaced a per-method schedule. Re-check before committing a year of indexing spend to it.
The comparison nobody sells you¶
Every provider comparison — including the honest ones — is framed as a choice between providers. The data above suggests the framing is wrong. No provider is cheapest across the board, the spread between methods reaches 10× inside a single provider, and the cheapest-per-method assignment is stable and knowable:
# Reads to Alchemy, history and getProgramAccounts to dRPC, writes and DAS to Helius.
[[providers]]
name = "alchemy"
url = "https://solana-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}"
methods = ["getAccountInfo", "getBalance", "getMultipleAccounts"]
[[providers]]
name = "drpc"
url = "${DRPC_URL}" # copy your exact endpoint from the dRPC dashboard
methods = ["getBlock", "getTransaction", "getSignaturesForAddress", "getProgramAccounts"]
[[providers]]
name = "helius"
url = "https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}"
That is what methods does — restrict a provider to the calls you
want it to serve. Helius is left unrestricted here so it catches everything else and acts as the
failover leg.
To be clear about the incentive: RPC Plane is the proxy that makes this arrangement practical, and we build it. But the finding stands on its own — you can act on the table above with nginx, with application-level routing, or by simply moving your indexer to a different key.
Head to head¶
- Helius vs QuickNode — the archival premium, and where the crossover sits
- Helius vs Alchemy — the two cheapest standard reads, and the DAS gap
- Alchemy vs QuickNode — cheapest reads against cheapest history
Setup guides¶
Helius · QuickNode · Alchemy · Triton One · anything else
dRPC, OnFinality and Chainstack have no setup page yet — they are configured like any other endpoint; see other providers and the per-method rates in provider pricing.