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

> getProgramAccounts is the one Solana read whose cost depends on what comes back, not on the call. Four billing models priced on the same scan workload, with the paging trick that cuts the credit bill.

- Canonical: https://triport.io/blog/getprogramaccounts-pricing-and-limits-across-solana-providers
- Published: 2026-11-03
- Updated: 2026-11-03
- Author: Triport Engineering
- Category: Comparisons
- Networks: Solana

## TL;DR

- A getProgramAccounts call costs 10 credits on Helius, 30 credits (the default Solana weight) on QuickNode, $10 per million calls plus $0.08 per GB on Triton, and, on Triport, no per-call charge at all: a dedicated heavy bucket of 2, 5, 20 and 80 per second on trial, Basic, Pro and Business.
- For a workload of 10.368 million filtered scans a month (4 a second), the same traffic costs about $517 on Helius, $249 on QuickNode, $187 to $933 on Triton depending on response size, and $20 on Triport Basic.
- The ranking flips on peak rate and response size: at 25 scans a second Helius needs about $3,239 in credits, while Business at $499 covers the same rate here, and a 1 MB response makes bytes the biggest line on a bandwidth-metered plan.

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](https://triport.io/blog/solana-das-api-cost). 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**.

| | Calculation | Monthly |
|---|---|---|
| Helius Business | 10.368M x 10 = 103.68M credits; $499 + (103.68M - 100M) x $5/M | **$517.40** |
| QuickNode Accelerate | 10.368M x 30 = 311.04M credits, inside 450M; 4 req/s inside 125 | **$249** |
| Triton, 100 KB responses | 10.368M x $10/M = $103.68; 1,036.8 GB x $0.08 = $82.94 | **$186.62** |
| Triton, 1 MB responses | $103.68; 10,368 GB x $0.08 = $829.44 | **$933.12** |
| Triport Basic | 4 req/s inside the 5 heavy limit | **$20** |

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](https://triport.io/learn/getprogramaccounts-empty-result) 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](https://triport.io/learn/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](https://triport.io/docs/sol/json-rpc/getProgramAccounts), [getProgramAccountsV2](https://triport.io/docs/sol/json-rpc/getProgramAccountsV2) and [Solana limits](https://triport.io/docs/sol/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.

## Try it

- Reference: [getProgramAccounts reference](https://triport.io/docs/sol/json-rpc/getProgramAccounts)
- Network: [Solana RPC plans and limits](https://triport.io/solana-rpc)