Skip to content

Solana RPC for indexers

An indexer is the workload that breaks the default provider choice. It is 70–80% getBlock, getTransaction and getSignaturesForAddress — the exact methods that carry an archival premium almost everywhere — and the provider most Solana developers reach for first is the worst one for it by a factor of seven.

What this workload costs

Modelled on a mix of 45% getBlock, 25% getTransaction, 10% getSignaturesForAddress, 10% getProgramAccounts, 10% getAccountInfo, computed from the pricing dataset, backfill pricing (below firstAvailable + 5,000):

Provider Blended $/M At 100M calls/month
dRPC $6.00 $600
OnFinality $7.50 $750
Triton One $10.00 $1,000
QuickNode $15.00 $1,500
Alchemy $15.75 $1,575
Chainstack $18.00 $1,800
Helius $45.50 $4,550

Helius is the cheapest provider on the board for a trading bot and the most expensive by a wide margin here. Nothing about Helius changed — the workload did. Helius bills archival reads at 10 credits against 1 for a standard call, so a mix that is three-quarters history pays close to ten times its headline rate.

dRPC and OnFinality are cheap here for the same structural reason in reverse: both charge one flat weight for every method, so history costs them what a getBalance costs. A flat-rate provider is always going to win a history-heavy mix.

Rates verified 2026-09-06 against each provider's published pricing. See price per method for the underlying weights and compare providers for the head-to-head crossovers.

These are overage rates, not subscription rates

Every figure above is the pay-as-you-go / overage price — what you pay per call once an included quota is spent. A subscription's effective rate differs, and at indexer volumes you will be on a plan, not on overage. Use these to compare shapes, then check the plan ladder.

The archive cliff is not where you think

Chainstack is the one provider that distinguishes history near the chain tip from real backfill. Its 2× archive multiplier applies to eight named methods and only when the slot is below firstAvailable + 5,000. A live indexer following the tip pays 1 RU; only backfill pays 2.

That means Chainstack's $18.00 above is its backfill number. An indexer that has finished its backfill and is only following new blocks pays $10.00/M — moving it from second-worst to mid-pack. No other provider on the list makes this distinction.

If your indexer has a long backfill phase and a long steady-state phase, they are two different cost problems and it is reasonable to answer them with two different providers.

Where a proxy helps, and where it doesn't

The per-method cheapest provider for this mix:

Method Share Cheapest $/M
getBlock 45% dRPC $6.00
getTransaction 25% dRPC $6.00
getSignaturesForAddress 10% dRPC $6.00
getProgramAccounts 10% dRPC $6.00
getAccountInfo 10% Alchemy $4.50

Splitting by method saves 2.5% over just using dRPC for everything. That is not a reason to run a proxy. dRPC wins four of five methods outright, and the fifth is 10% of traffic.

Be honest about this: for an indexer, cost is a provider-selection problem, not a routing problem. Pick the flat-rate provider and stop. What a proxy is actually for here is the other half — an indexer that stalls because one provider is 14 slots behind tip silently writes wrong data, and a backfill that dies at 3am on a 503 costs you the run.

Config

Two providers, history to the cheap flat-rate one, account reads to Alchemy, with each able to cover the other if it fails:

[routing]
strategy = "failover_ordered"

# Primary: dRPC is flat-rate, so getBlock costs what getBalance costs.
# With failover_ordered, config order is the priority order.
[[providers]]
name = "drpc"
url  = "${DRPC_URL}"    # copy your endpoint from the dRPC dashboard

# Backup: takes the whole load only when dRPC's circuit is open.
[[providers]]
name = "alchemy"
url  = "https://solana-mainnet.g.alchemy.com/v2/${ALCHEMY_API_KEY}"

Both entries serve every method, so either can absorb the whole load when the other is down. That is the trade: a strict methods allowlist per provider gives you the cheapest possible bill and no failover path for those methods. For a backfill that runs for days, redundancy is worth more than the 2.5%.

RPC Plane does not route by cost

It routes by health, score, priority or weight — never by price. The split above is one you choose and encode in config; the proxy will not compute it for you. Cost-aware routing is on hold, and the binary has no pricing table.

Slot drift is the failure that corrupts data

For most workloads a provider that lags the chain tip is a latency problem. For an indexer it is a correctness problem: you read a block that is not there yet, get an empty or partial answer, and write it down as fact.

RPC Plane tracks each provider's reported slot against the highest slot any provider has reported and scores the difference. A provider that drifts past your threshold stops receiving traffic before it can feed you stale history. See health scoring for the weights and routing for what happens when a provider is taken out of rotation.

[health]
slot_drift_threshold = 10    # slots behind tip before the freshness score hits 0
w_slot               = 0.4   # raise it: for an indexer, drift matters more than latency
w_latency            = 0.2