Provider pricing¶
RPC Plane publishes a machine-readable pricing database at pricing.rpcplane.dev — one JSON document with per-method rates for the providers below. This page is the human-readable version of it: what each provider charges per method, and which methods actually drive your bill.
Cost-aware routing is not shipped
The pricing database is a reference, not a routing input. RPC Plane v0.11.0 does not read
it and does not route on cost — there is no cost_aware setting. Use these numbers to choose
providers and to decide which methods to keep off an expensive one with
methods; the router itself scores on latency, errors, slot
drift and success rate only. See health scoring.
Why method-level pricing matters¶
Providers don't charge a flat rate per request. A getAccountInfo call and a getBlock call can differ by 10× in cost on the same plan. The methods that drive your bill are usually a small subset — typically history reads (getBlock, getTransaction, getSignaturesForAddress) and DAS queries (getAsset*, searchAssets).
So the useful question is not "which provider is cheapest?" but "which provider is cheapest for my method mix?" A workload that is 95% getAccountInfo and one that is 95% getBlock have different right answers, and the tables below are laid out to make that comparison directly.
Rates at a glance¶
All rates are pay-as-you-go / overage rates — the per-call cost once an included monthly quota is exhausted. Subscription tier sizes are not modeled here.
Where a provider's rate improves with tier, the figure quoted is its best published non-enterprise rate — the best price you can reach without signing a custom contract. That is the rule the pricing dataset behind this page has always stated, and every section below gives the full tier ladder so you can see what was picked and why. Quoting one provider's enterprise rate against another's entry rate is the most common way these comparisons go wrong, and it is a mistake this page made until 2026-09-06.
| Provider | Billing model | Standard call ($/M) | getBlock ($/M) |
DAS ($/M) |
|---|---|---|---|---|
| Alchemy | Compute units, $0.45/M CU | $4.50 | $18.00 (4×) | — |
| Helius | Credits, $5/M | $5.00 | $50.00 (10×) | $50.00 (10×) |
| dRPC | Flat 20 CU/call, $0.30/M CU | $6.00 | $6.00 (no premium) | — |
| OnFinality | 2 RU/call, $3.75/M RU | $7.50 | $7.50 (no premium) | — |
| Chainstack | Request units, $10/M RU | $10.00 | $10.00–$20.00 (archive 2×) | — |
| Triton One | Metered (requests + bandwidth) | $10.00 + BW | $10.00 + BW | $50.00 + BW |
| QuickNode | Credits, $0.50/M | $15.00 | $15.00 (no premium) | $30.00 (2×) |
Standard call reference = getAccountInfo. DAS = Metaplex Digital Asset Standard (getAsset, getAssetsByOwner, searchAssets, etc.). BW = $0.08/GB response bandwidth (Triton only).
All rates verified 2026-09-06 against each vendor's published pricing and docs (linked per section). The JSON database at pricing.rpcplane.dev carries its own updated_at; where the two differ, the vendor's page wins.
Helius¶
Model: credits — $5.00 per million credits (all paid tiers)
| Method category | Credits per call | Effective $/M calls |
|---|---|---|
| Standard (getAccountInfo, getBalance, sendTransaction, …) | 1 | $5.00 |
| Archival reads (getBlock, getTransaction, getSignaturesForAddress, …) | 10 | $50.00 |
| DAS / Metaplex (getAsset, getAssetsByOwner, searchAssets, …) | 10 | $50.00 |
| getProgramAccounts | 10 | $50.00 |
Helius charges uniformly for all archival and DAS methods. Standard account/state reads are cheap; anything that touches history or the asset index is 10×.
sendTransaction is a standard call at 1 credit — it is not free. The $5.00/M figure holds across paid tiers: Developer is $49 for 10M credits, Business $499 for 100M, Professional $999 for 200M.
Sources: helius.dev/pricing. Verified 2026-09-05. See the Helius setup page for plans, rate limits and the free tier.
QuickNode¶
Model: API credits — $0.50 per million credits (Business tier; Build tier is $0.62/M)
| Method category | Credits per call | Effective $/M calls |
|---|---|---|
| All standard Solana methods (incl. getBlock, getTransaction) | 30 | $15.00 |
| Advanced API — getAsset* | 60 | $30.00 |
| Large scans — getLargestAccounts, getSupply, getTokenLargestAccounts | 120 | $60.00 |
Notable: QuickNode does not charge a premium for history reads. getBlock costs the same as getAccountInfo. The only differentiation is DAS/advanced (2×) and large scans (4×).
Sources: quicknode.com/pricing · api-credits/solana. Verified 2026-09-05 — Solana sits in the 30-credit base tier, with a 2× multiplier on Advanced/DAS calls and 4× on large calls. See the QuickNode setup page.
Triton One¶
Model: metered — per request plus response bandwidth ($0.08/GB)
Triton bills two components on every call. The bandwidth charge is minor for small responses but significant for history calls with large payloads.
| Method category | $/M calls | Typical response size | Bandwidth $/M calls | Total $/M |
|---|---|---|---|---|
| Standard RPC (getAccountInfo, getBalance, getSlot, …) | $10 | ~0.5 KB | ~$0.04 | ~$10 |
| History / ledger (getBlock, getTransaction, getSignaturesForAddress) | $10 | ~500 KB (getBlock) | ~$40 | ~$50 |
| Indexed accounts (getProgramAccounts, getTokenAccountsByOwner) | $10 | varies | varies | $10+ |
| DAS / Metaplex (getAsset*, searchAssets) | $50 | ~2 KB | ~$0.16 | ~$50 |
The getBlock bandwidth estimate assumes ~500 KB average block payload (compressed); actual size varies by block fullness, so treat the history row as an order-of-magnitude figure rather than a quote.
Triton also requires a $125 prepaid deposit in stablecoins — non-refundable, valid 12 months — so there is no free way to evaluate it.
Sources: triton.one/pricing. Verified 2026-09-05. See the Triton One setup page.
Alchemy¶
Model: compute units (CU) — $0.45 per million CU (rate drops to $0.40/M beyond 300M CU/month)
| Method | CU per call | Effective $/M calls |
|---|---|---|
| getAccountInfo, getBalance, getTokenAccountsByOwner | 10 | $4.50 |
| sendTransaction, simulateTransaction, getProgramAccounts, getSlot | 20 | $9.00 |
| getTransaction, getBlock, getSignaturesForAddress | 40 | $18.00 |
The PAYG plan starts at 300 RPS. Alchemy also has the largest free tier of the providers here — 30M CU/month at 25 req/s.
Sources: alchemy.com/pricing · Solana compute unit costs. CU weights confirmed against Alchemy's published Solana table and verified 2026-09-05. See the Alchemy setup page.
Chainstack¶
Model: request units (RU) — 1 RU per call, 2 RU for an archive read. The price per RU depends on the plan:
| Plan | Price | Included RU/mo | RPS | Overage $/M RU |
|---|---|---|---|---|
| Developer | $0 | 3M | 25 | $20.00 |
| Growth | $49 | 20M | 250 | $15.00 |
| Pro | $199 | 80M | 400 | $12.50 |
| Business | $499 | 200M | 600 | $10.00 |
| Enterprise | $990+ | 400M+ | unlimited | $5.00 |
At Business — the best non-enterprise rate, and the basis used throughout this page:
| Call type | RU per call | Effective $/M calls |
|---|---|---|
| Standard | 1 | $10.00 |
| Archive read | 2 | $20.00 |
Enterprise halves that again to $5.00 and $10.00, but it starts at $990/month and is quoted per contract, so it is excluded here for the same reason every other provider's enterprise pricing is.
There are no per-method RU multipliers on Solana — every method costs the same 1 RU. The only differentiation is archive vs. non-archive, and Chainstack's definition of "archive" on Solana is narrower than a flat 2× implies.
Correction — 2026-09-06
This page previously quoted Chainstack at $5.00/M standard and $10.00/M archive — the Enterprise rate, from $990/month, compared against every other provider's non-enterprise rate. The pricing dataset's own stated methodology excludes exactly that ("best non-enterprise published rate is used where tiers differ"), and its Chainstack note said outright that the enterprise rate had been used. At the best non-enterprise tier, Business, the figures are $10.00 and $20.00 — 2× higher. The effect was to present Chainstack as the cheapest history read on the comparison pages when it is mid-pack.
What counts as an archive read on Solana¶
Archive billing applies to exactly eight methods, and only when the request targets a slot below firstAvailable + 5,000:
getTransaction · getBlock · getBlockTime · getBlocks · getBlocksWithLimit · getSignaturesForAddress · getFirstAvailableBlock · getSignatureStatuses
Two of them — getSignaturesForAddress and getFirstAvailableBlock — are always billed as archive regardless of slot age.
The practical consequence is worth spelling out: an indexer tailing the chain tip calls getBlock and getTransaction on recent slots, and those bill at 1 RU, not 2. Chainstack's history premium applies to backfill, not to live indexing. No other provider here makes that distinction — Helius charges its 10× archival rate on getBlock whether the slot is a minute old or a year old.
Per-method rate limits¶
Chainstack publishes per-method RPS caps on Solana that sit below the plan-level limit:
| Method | Cap |
|---|---|
getSupply |
2 RPS (paid plans only) |
getTokenAccountsByOwner |
80 RPS in most regions |
getBlock |
400 RPS |
getBlockTime, getBlocks, getBlocksWithLimit |
500 RPS |
getBlocks and getBlocksWithLimit are additionally capped at a 500K block range per call. As with Helius, the headline plan RPS is not the ceiling you hit first — see working around a per-method limit.
Sources: chainstack.com/pricing · request units · Solana methods. Verified 2026-09-06.
dRPC¶
Model: compute units — every method costs a flat 20 CU at $0.30 per million CU, which works out to $6.00 per million calls, for every method.
| Method category | CU per call | Effective $/M calls |
|---|---|---|
| Every supported method | 20 | $6.00 |
dRPC moved off variable per-method pricing on 2 June 2025. Weights previously ranged from 10 CU for cheap calls to 60 CU for eth_getLogs and trace methods; they are now uniform across every method and every chain dRPC supports. Volume discounts still apply at higher usage.
That flat rate makes dRPC the cheapest history read on this page by a wide margin — $6.00/M against QuickNode's $15.00 and Helius's $50.00 — and the cheapest getProgramAccounts as well. It does not serve Metaplex DAS methods, so NFT and compressed-asset workloads cannot be costed on it at all.
Free tier: 210M CU per 30 days — roughly 10.5M calls a month, the largest free allowance of any provider here. The catch is that it is served over dRPC's public node pool, which is slower and less reliable than the paid endpoints. Treat it as a development or failover leg rather than a free production tier.
Sources: compute units · flat-rate pricing announcement · Solana API. Verified 2026-09-06.
OnFinality¶
Model: response units (RU) — every Solana method carries a uniform weight of 2 RU. The price per RU depends on the plan:
| Plan | Price | Included RU | Rate limit | Overage $/M RU | Effective $/M calls |
|---|---|---|---|---|---|
| Developer | $0 | 400K/day | 40 RU/s | — | — |
| Growth | $49 | 20M/mo | 200 RU/s | $6.00 | $12.00 |
| Accelerate | $249 | 100M/mo | 500 RU/s | $3.75 | $7.50 |
| Ultimate | Custom | Custom | Custom | Custom | — |
Accelerate is the best non-enterprise rate and the figure used elsewhere on this page; Ultimate is quoted per contract and excluded.
As with dRPC and Chainstack there are no per-method multipliers — OnFinality's published Solana table lists the same 2 RU against all 50+ HTTP and WebSocket methods, archival reads included.
Note that the Developer allowance is expressed per day, not per month: 400K RU/day is about 200K calls a day at 2 RU each.
sendTransaction is not in the documented method set
OnFinality's published Solana method table covers reads and subscriptions but does not list
sendTransaction. Confirm write support with OnFinality before routing writes to it — or
restrict it to reads with methods, which is the safer default:
Sources: onfinality.io/pricing · Solana methods and response units. Verified 2026-09-06.
Providers without per-method pricing¶
A provider is in the pricing database if its published material lets you compute the cost of every method — that can be a per-method weight table (Alchemy, Helius, QuickNode) or a documented flat rate (dRPC, OnFinality, Chainstack). It is out if any part of the method surface is unpriced, because a partial table invites exactly the mistake this page exists to prevent: comparing the calls that are published and assuming the rest follow.
The providers below were checked against that rule and did not clear it. They work with RPC Plane exactly like any other endpoint — see other providers — there is simply no complete rate data to compare them on here.
| Provider | Notes |
|---|---|
| GetBlock | CU model, $0.41/M CU (Pro) — but CU weights per Solana method not documented |
| Ankr | Flat $50/M all Solana requests, no method differentiation |
| Shyft | Flat-rate RPS subscriptions; no per-call metering on current plans |
| RPC Fast | A standard Solana call is 1 CU and overage is $5.00/M CU, so standard reads work out to $5.00/M — but no weight is published for archive, history or DAS calls, so a real workload can't be costed end to end |
| Syndica | Free tier is 10M requests/month at 100 RPS with 100 GB transfer; paid tiers are quoted per plan, with no published per-request or per-method rate |
| Blockdaemon | 3M CU free, Starter at $600/month for 15M CU — no published per-method CU weights |
| Uniblock | An aggregation layer rather than a node operator: it routes to upstream providers, so its cost is theirs plus a margin, and no per-method rate is published |
GetBlock, Ankr and Shyft were last checked 2026-05-14; the remaining four were checked 2026-09-06.
Cost calculator¶
This page is the reference data. To put your own numbers against it, use the
cost calculator on rpcplane.dev — enter your
expected monthly call volumes by method type and it shows the effective cost per provider
side-by-side.