# What a Solana DAS API workload really costs: per-call credits vs flat plans

> DAS calls are the most expensive reads on credit-metered Solana plans. One workload priced three ways, with every unit price sourced and dated, and the break-even point where the cheapest model changes.

- Canonical: https://triport.io/blog/solana-das-api-cost
- Published: 2026-09-22
- Updated: 2026-09-22
- Author: Triport Engineering
- Category: Comparisons
- Networks: Solana

## TL;DR

- Under a credit model every DAS call carries a higher weight — 10 credits per call on Helius, against 1 for a standard call — and each plan also caps DAS requests per second, so the plan you need is set by whichever of volume or peak rate binds first.
- For a workload of 2.4 million DAS calls a month with a 20-per-second peak, the published prices give $499 on Helius (the smallest plan whose DAS rate covers the peak), about $120 plus bandwidth on Triton's pay-per-call rate, and $249 on Triport Pro, where DAS is gated by plan and not metered per call.
- Per-call pricing wins below roughly 5 million DAS calls a month if your peak is modest; a flat plan wins above that or when the peak forces a bigger credit plan — so price your own volume and peak, not a vendor's example.

The Digital Asset Standard (DAS) API is how Solana applications read NFTs, compressed NFTs and fungible tokens without scanning accounts themselves: one call returns the assets a wallet owns, a collection's members, or the proof a compressed-NFT transfer needs. Because each call is answered from an index and can return large pages, providers price DAS above ordinary reads.

Helius's credits documentation (read 2026-09-22) states the weights plainly — a standard RPC call is 1 credit and each DAS call is 10 — but stops at the unit price. A team budgeting a DAS-heavy product needs the next step: a workload, priced under each model, with the point where the answer flips. That is this post. For a method-by-method reference of DAS itself, see our [DAS reference](https://triport.io/learn/das); for the general theory of credits, compute units and flat plans, see [RPC credits vs flat pricing](https://triport.io/learn/rpc-credits-vs-flat-pricing).

## What DAS calls are and why they cost more

A DAS method answers a question that the base Solana RPC cannot answer in one call. `getAssetsByOwner` returns every asset a wallet holds, with metadata, paged. `getAssetsByGroup` returns the members of a collection. `searchAssets` combines conditions. `getAssetProof` returns the Merkle proof a compressed NFT needs to be transferred. All of them read from an index built alongside the chain rather than from live account state — responses carry a `last_indexed_slot` — and the work per call is larger and less predictable than a `getBalance`.

Providers recover that cost in one of three ways:

1. **A per-call weight inside a credit allowance.** Each plan includes a number of credits a month; a DAS call spends more credits than a standard call; beyond the allowance you pay overage or upgrade.
2. **A per-call price.** You prepay and each DAS call has a price per million.
3. **Access by plan.** DAS is part of a plan or it is not, and calls are not weighted.

The three produce very different bills for the same traffic.

## The credit model: weight × calls, plus a DAS rate cap

These are Helius's published plans as recorded in our provider dataset:

| Plan | Price / month | Included credits | DAS requests / s | Overage | Source, verified |
|---|---|---|---|---|---|
| Free | $0 | 1,000,000 | 2 | none (upgrade required) | helius.dev/pricing, 2026-09-22 |
| Developer | $49 | 10,000,000 | 10 | $5 per 1M credits | helius.dev/pricing, 2026-09-22 |
| Business | $499 | 100,000,000 | 50 | $5 per 1M credits | helius.dev/pricing, 2026-09-22 |
| Professional | $999 | 200,000,000 | 100 | $5 per 1M credits | helius.dev/pricing, 2026-09-22 |

The credit weights come from helius.dev/docs/billing/credits, verified 2026-09-22: 1 credit per standard call, 10 per DAS call.

With DAS at 10 credits a call, the monthly credit need is `DAS calls × 10`, and every ordinary RPC call your app makes spends from the same allowance. There is also a second constraint that is easy to miss: each plan caps DAS **requests per second**. A workload whose average fits the Developer allowance but whose peak is 20 DAS calls per second does not fit Developer at all; it needs Business.

## The pay-per-call model

Triton One publishes a prepaid, pay-as-you-go rate (triton.one/pricing, verified 2026-09-22): DAS calls at **$50 per million**, plus bandwidth at $0.08 per GB, against a $125 minimum deposit that is valid for 12 months. It states no fixed request-rate entitlement on its pricing page. The bill is proportional to calls, with no step between plans — cheap at low volume, linear at high volume. Bandwidth is not modelled below, because it depends on page sizes we cannot know for you, so every Triton figure here is a lower bound.

## The flat model: DAS by plan, not by call

On Triport, DAS is gated by plan and not metered per call:

- The 7-day trial has no DAS access.
- **Basic ($20)**: "Part of the method set", as the [pricing](https://triport.io/pricing) table puts it. The plan matrix does not name which methods, so if your product depends on a specific one, do not plan on Basic.
- **Pro ($249)** and above: "All methods" — every DAS method we sell: `getAsset`, `getAssetProof`, `getAssetsByGroup`, `getAssetsByOwner`, `getTokenAccounts` and `searchAssets`.

A DAS call carries no weight and there is no credit allowance to run out of — plans are a flat monthly price with no credits, compute units or overage. Responses show it: on 2026-09-22 a `getAsset` call answered with `X-RateLimit-Category: sol_das` and `X-RateLimit-Limit: -1`, the value our gateway uses for "no per-second budget for this category". That is not the same as unlimited capacity, and we do not publish a DAS requests-per-second figure; if your peak is a hard requirement, test it during evaluation. The product details are on the [DAS API feature page](https://triport.io/features/das-api).

## A worked workload

Take a wallet app that shows each user's NFTs and tokens. Assumptions, stated so you can replace them:

- 10,000 active users a day;
- each session makes 8 DAS calls (three pages of `getAssetsByOwner`, five `getAsset` look-ups);
- 30 days a month, so **2.4 million DAS calls a month**;
- traffic is uneven: the busiest second of the day sees **20 DAS calls**;
- ordinary RPC calls are ignored here, which flatters the credit model slightly, since they spend the same credits.

**Helius.** 2.4M calls × 10 credits = 24M credits. Developer includes 10M; the overage would be 14M credits × $5 per million = $70, for $119 in total — but Developer allows 10 DAS requests per second, and the peak is 20. The smallest plan that allows 20 is Business: **$499**, with 76M credits to spare.

**Triton.** 2.4M × $50 per million = **$120** plus bandwidth, drawn from a prepaid deposit.

**Triport.** The workload needs `getAssetsByOwner` and `getAsset` with certainty, so Pro: **$249**, whatever the call count.

The same app at other sizes, same assumptions about call mix:

| DAS calls / month | Peak DAS / s | Helius (plan) | Triton (+ bandwidth) | Triport |
|---|---|---|---|---|
| 500,000 | 5 | $49 (Developer, 5M credits) | $25 | $249 (Pro) |
| 2,400,000 | 20 | $499 (Business; Developer's DAS rate is 10) | $120 | $249 (Pro) |
| 10,000,000 | 50 | $499 (Business, exactly 100M credits) | $500 | $249 (Pro) |

At the top row a flat plan is the expensive choice, and we say so. At the bottom row the credit plan is right at its allowance edge: a single extra ordinary call per DAS call would push it into overage.

## Break-even logic, not a winner

Two break-even points fall out of the published prices.

- **Against pay-per-call:** $249 ÷ $50 per million = about **5 million DAS calls a month**. Below that, Triton's rate (before bandwidth) is cheaper than Triport Pro; above it, Pro is cheaper.
- **Against credits:** Developer plus overage reaches $249 at 40M overage credits, i.e. 50M credits, or **5 million DAS calls a month** — but only while your peak stays within Developer's 10 DAS requests per second. Once the peak needs 50 per second, the credit option starts at $499 regardless of volume.

So the variables that decide your bill are, in order: the peak DAS rate, the monthly DAS volume, how many ordinary calls share the credit allowance, and response size where bandwidth is billed. Plug your own numbers into the [DAS cost calculator](https://triport.io/tools/das-cost), and see the [RPC pricing index](https://triport.io/research/rpc-pricing-index) for the dated source of every competitor price.

## When per-call pricing is the better model

- **Low or bursty-but-small volume.** A few hundred thousand DAS calls a month is cheapest on a per-call price or a small credit plan. A flat Pro plan is paying for headroom you do not use.
- **You need a published per-second DAS figure.** Credit plans state a DAS requests-per-second cap per plan; we do not publish one for DAS. If a contractual peak matters more than the monthly bill, that is a reason to choose a plan that states it.
- **One method on Basic.** If the method you need turns out to be in Basic's subset, $20 beats every row above — but confirm it first, because the plan matrix does not name the subset.

For the full per-plan picture across networks, including the rest of the Solana limits, see [pricing](https://triport.io/pricing).

## When this is the wrong approach

- **You need live account state.** DAS answers from an index. For the current state of one account, read it with `getAccountInfo`; for a stream of changes, subscribe.
- **You are pricing a whole product, not DAS.** Ordinary reads, sends and streams usually dominate the bill. Price them together with the [RPC cost calculator](https://triport.io/tools/rpc-cost) rather than optimizing the DAS line alone.
- **The prices have moved.** Every competitor number here was verified on 2026-09-22 and will age. Re-check before you sign anything.

## Sources

1. Helius, Credits — https://www.helius.dev/docs/billing/credits, read 2026-09-22 (1 credit per standard call; `getProgramAccounts` and each DAS call 10).
2. Helius, Pricing — https://www.helius.dev/pricing, read 2026-09-22 (Free $0 / 1M credits / 2 DAS req/s; Developer $49 / 10M / 10; Business $499 / 100M / 50; Professional $999 / 200M / 100; overage $5 per 1M credits on paid plans). Recorded in our provider dataset with `last_verified` 2026-09-22.
3. Triton One, Pricing — https://triton.one/pricing, read 2026-09-22 (DAS $50 per 1M calls plus $0.08/GB; $125 minimum prepaid deposit valid 12 months; no fixed request-rate entitlement stated).
4. Triport, [getAssetsByOwner](https://triport.io/docs/sol/json-rpc/getAssetsByOwner) and [getAsset](https://triport.io/docs/sol/json-rpc/getAsset) references; DAS feature gating from the plan matrix (trial none, Basic part of the set, Pro and above all six methods), as shown on [pricing](https://triport.io/pricing). `getAsset` and `getAssetsByOwner` answered on production on 2026-09-22 with `X-RateLimit-Category: sol_das`, `X-RateLimit-Limit: -1` and a `last_indexed_slot` field.
5. Arithmetic: 10,000 × 8 × 30 = 2,400,000; 2,400,000 × 10 = 24,000,000 credits; (24M − 10M) × $5/1M = $70; 2,400,000 × $50/1M = $120; $249 ÷ $50 = 4.98M; $200 ÷ $5 × 1M = 40M credits → 50M credits ÷ 10 = 5M calls.

## Try it

- Reference: [getAssetsByOwner — the typical DAS workhorse](https://triport.io/docs/sol/json-rpc/getAssetsByOwner)
- Network: [Solana RPC — RPC, Yellowstone gRPC and DAS](https://triport.io/solana-rpc)