getProgramAccounts pricing across Solana providers: credits, calls, bytes and buckets

Most Solana reads cost the node roughly the same each time. getProgramAccounts (gPA) does not: it scans every account a program owns, applies your filters and returns whatever matches, so one call can be a few hundred bytes or a few hundred megabytes. Providers deal with that in four different ways, and the way they choose decides which scan workloads are cheap.

We covered the same question for the Digital Asset Standard in our DAS cost post. This post is the gPA version, with prices read on 2026-11-01 from each vendor's own pages and arithmetic you can redo.

Four ways to bill the same scan

Helius: a fixed credit weight. The credits page puts getProgramAccounts at 10 credits against 1 for a standard call, and points to getProgramAccountsV2 at 1 credit for paginated queries. The weight does not depend on response size. Plans: Developer $49 (10M credits), Business $499 (100M), Professional $999 (200M), overage $5 per million credits.

QuickNode: the default weight. Its credits page lists Solana under "All methods" at 30 credits and names no separate gPA weight, only a 2x multiplier for getAsset methods and 4x for a short list including getSupply and getLargestAccounts. We therefore price gPA at 30 and flag that as the one assumption: if QuickNode documents an exception, the figure moves. Plans: Build $49 (80M credits, 50 req/s), Accelerate $249 (450M, 125 req/s), Scale $499 (950M, 250 req/s).

Triton: calls plus bytes. Triton's published rate for standard RPC is "$0.08 / GB bandwidth + $10 / million calls", prepaid with a $125 minimum. It is the only model of the four where the size of your result appears on the bill.

Triport: a heavy bucket. There is no per-call weight. getProgramAccounts, getProgramAccountsV2 and getTransactionsForAddress share the sol_read_rpc_heavy category, with sustained limits of 2 (trial), 5 (Basic, $20), 20 (Pro, $249) and 80 (Business, $499) requests per second, each with a 2x burst bucket. Enterprise has no per-category cap. The bill is the plan price; the cost of a big scan is that it uses up a small bucket.

One workload, priced four ways

A program-state refresher: 40 distinct filtered scans, each repeated every 10 seconds. That is 4 scans per second, 4 x 2,592,000 = 10.368 million calls a month.

Three things stand out, and one of them cuts against us.

First, the credit models are insensitive to response size and the byte-metered model is not. At 1 MB per response Triton's bandwidth line is eight times its per-call line. If you can shrink responses with dataSlice and tight filters, Triton's bill falls with them; the credit plans do not reward you.

Second, Triport's figure only holds because the workload is 4 scans a second. The bucket is the constraint, so the cheapest plan is the smallest one whose heavy limit covers your peak.

Third, the $20 is not the same product. Basic has 60 ordinary read requests per second and no gRPC or Shred stream; the plans it is compared with in this table include different things. Compare your whole workload, not this line.

Where the answer flips: 25 scans a second

Raise the refresher to 25 scans a second, 64.8 million calls a month:

• Helius. 648M credits. Professional: $999 + (648M - 200M) x $5/M = $999 + $2,240 = $3,239. At 25 req/s the rate is fine, so the credits decide it.
• QuickNode. 64.8M x 30 = 1,944M credits. Scale's 250 req/s fits; $499 + (1,944M - 950M) x $0.53/M = $499 + $527 = $1,026.
• Triton. 64.8M x $10/M = $648 plus bytes (about $518 at 100 KB).
• Triport. 25 scans a second needs more than Pro's 20, so Business at $499 (80 allowed).

Here the flat model is cheapest in the table, but only because 25 a second sits under the 80 ceiling. Past 80 sustained heavy requests a second, the next step is Enterprise, by contract, and we cannot quote it here.

The paging trick on credit plans

Helius prices getProgramAccountsV2 at 1 credit. A scan that returns 50,000 accounts costs 10 credits as a single getProgramAccounts. Paged at limit: 10000 it takes 5 pages plus a final empty page (Helius's docs say the end of pagination is only indicated when no accounts are returned), which is 6 calls and 6 credits, and the node handles smaller responses. The saving is 40% on that scan and grows when the result is bigger.

Triport has the same paging method with limit and paginationKey, but every page is one heavy-bucket request. On a flat plan paging does not make a scan cheaper; it makes it manageable: Helius states that large queries that previously timed out work with pagination, and the same logic applies to a big result on any provider. At 20 heavy requests a second on Pro, a 6-page scan takes at least 0.3 seconds of the whole bucket's capacity.

When this is the wrong approach

If the scan is your product, a credit or per-call plan is the wrong shape. Re-scanning a program every few seconds is replacing what a stream does: subscribe to account updates with Yellowstone gRPC filtered by program and dataSize, scan once to seed, then apply deltas. A seed plus a stream costs one scan, not 8,640 a day.

If your filters return nothing and you pay for the scan anyway, check the filter first; the empty-result guide lists the usual causes (wrong dataSize, wrong memcmp offset or encoding).

Also be careful about size. Neither the Triport reference nor the Helius page states a maximum response size or timeout for an unfiltered scan of a very large program, and we do not publish one. Test your largest filter on a trial before you size the plan.

Finally, the numbers here assume 30 days of constant load. A scan that runs only during market hours is smaller on credit and per-call models and identical on a flat plan, so recompute with your own duty cycle. The theory behind credits and flat pricing is in RPC credits vs flat pricing.

Sources

1. Helius, Credits, https://www.helius.dev/docs/billing/credits, read 2026-11-01 (getProgramAccounts 10 credits; getProgramAccountsV2 1 credit; standard 1).
2. Helius, Pricing, https://www.helius.dev/pricing, read 2026-11-01 (Developer $49 / 10M; Business $499 / 100M; Professional $999 / 200M; $5 per million overage).
3. Helius, getProgramAccountsV2, https://www.helius.dev/docs/api-reference/rpc/http/getprogramaccountsv2, read 2026-11-01 (limit 1-10,000; paginationKey; end of pagination only when no accounts are returned).
4. QuickNode, API credits, https://www.quicknode.com/api-credits, read 2026-11-01 (Solana "All methods" 30 credits; getAsset 2x; getLargestAccounts and getSupply 4x; gPA not listed separately).
5. QuickNode, Pricing, https://www.quicknode.com/pricing, read 2026-11-01 (Build $49 / 80M / 50 req/s; Accelerate $249 / 450M / 125; Scale $499 / 950M / 250, overage $0.53 per million).
6. Triton One, Pricing, https://triton.one/pricing, read 2026-11-01 ($0.08 per GB + $10 per million calls; $125 minimum deposit).
7. Triport, getProgramAccounts, getProgramAccountsV2 and Solana limits, read 2026-11-01 (heavy bucket 2 / 5 / 20 / 80 requests per second).
8. Arithmetic: 4 x 2,592,000 = 10,368,000; x 10 = 103.68M credits; (103.68 - 100) x 5 = 18.40; x 30 = 311.04M; 10.368M x $10/M = 103.68; 10.368M x 100 KB = 1,036.8 GB x 0.08 = 82.94; x 1 MB = 10,368 GB x 0.08 = 829.44. 25 x 2,592,000 = 64.8M; x 10 = 648M; (648 - 200) x 5 = 2,240; x 30 = 1,944M; (1,944 - 950) x 0.53 = 526.8; 64.8M x 100 KB = 6,480 GB x 0.08 = $518.