What are credits?
Credits are a unit of account that we use to bill usage for RPCs, API requests, and data streaming products like LaserStream gRPC and LaserStream WebSocket. Every plan has a base number of credits, and every API call has an assigned credit cost. Below, we outline the credits per plan, credit costs by API, and credits for streaming data.Monthly Allocation
Credits reset monthly
Credit Priority
Credits are consumed in this order: monthly, prepaid, autoscaling
Flexible Billing
Pay for additional credits when needed
Base Credits by Plan
Here is a breakdown of the total number of credits that are included by default in each plan.All prices shown in dollars are in United States dollars (USD).
| Feature | Free | Developer | Business | Professional |
|---|---|---|---|---|
| Pricing | $0/month | $49/month | $499/month | $999/month |
| Monthly Credits | 1M | 10M | 100M | 200M |
Standard Credits
| Service | Credits | Notes |
|---|---|---|
| Standard RPC Calls | 1 | All RPC calls except those listed separately |
| getProgramAccounts | 10 | Get all accounts/data owned by a program |
| getProgramAccountsV2 | 1 | Paginated version of getProgramAccounts |
| simulateBundle | 1 | Simulate Jito Bundles |
| Priority Fee API | 1 | Estimate priority fees |
| DAS API | 10 | All DAS endpoints |
| Enhanced Transactions | 100 | Legacy transaction parsing, in maintenance mode |
| Parsed Events | 10 | Per request; scan adds 1 per history page scanned. Successor to Enhanced Transactions. All plans. |
Parsed Events
Parsed Events parses transaction signatures and address history into decoded instructions over REST. Available on all plans at 10 credits per request, forPOST /v1/parsed-events/transactions, POST /v1/parsed-events/transaction-history, and the IDL endpoints GET /v1/parsed-events/idl/{programId} and GET /v1/parsed-events/idl/{programId}/{slot}.
POST /v1/parsed-events/scan costs 10 credits per request plus 1 credit per history page scanned. A page holds up to 1,000 transactions, so a scan with the default budget of 10,000 transactions costs at most 20 credits.
Historical Data Credits
Historical data queries, sometimes called archival calls, cost 1 credit each. Exceptions aregetTransactionsForAddress, which starts at 10 credits and is metered by returned results, and getTransfersByAddress, which costs 10 credits.
| Method | Credits | Description |
|---|---|---|
getBlock | 1 | Retrieve block data and transactions for a specified slot |
getBlocks | 1 | Get list of blocks between two slots |
getBlocksWithLimit | 1 | Get blocks starting at a given slot with limit |
getSignaturesForAddress | 1 | Get transaction signatures for an address |
getTransaction | 1 | Retrieve transaction details for a specified signature |
getBlockTime | 1 | Get estimated production time of a block |
getSignatureStatuses | 1 | Get statuses for transaction signatures |
getInflationReward | 1 | Get inflation reward for a list of addresses for an epoch |
getTransactionsForAddress | 10+ | Enhanced transaction history with advanced filtering and sorting. Full transactions cost 10 credits per 100 returned; signatures-only responses cost 10 credits flat. Returns up to 1,000 full transactions or signatures. |
getTransfersByAddress | 10 | Parsed token and native SOL transfer history. Returns up to 100 transfers. |
getTransactionsForAddress
getTransactionsForAddress metering scales with what a successful response returns:
Examples:
Data Streaming Credits
Unlike regular credits that assign credits per call, data streaming products like LaserStream gRPC and LaserStream WebSocket assign credits per amount of data consumed. Parsed Streams, Preconfirmations, and Preprocessed Transactions are metered per delivered message instead.| Service | Credits | Notes |
|---|---|---|
| LaserStream WSS (standard Solana methods) | 2 | Per 0.1 MB of streamed data (uncompressed). All plans. |
| LaserStream WSS (Helius extensions) | 2 | Per 0.1 MB of streamed data (uncompressed). Developer, Business, and Professional plans. |
| LaserStream gRPC | 2 | Per 0.1 MB of streamed data (uncompressed). Business and Professional plans (Mainnet); all plans (Devnet). |
| Preprocessed Transactions — preprocessedSubscribe (WSS) | 0.1 | Per message (one message per delivered transaction). All paid plans. |
| Parsed Streams — parsedTransactionSubscribe (WSS) | 1 | Per delivered event (one event per matching transaction). All plans. |
| Preconfirmations — preconfSubscribe (WSS) | 10 | Per delivered message. All paid plans. Zero-message slots cost zero; slots with one or more delivered messages have a 300-credit minimum per subscription. |
| Data Add-on (Pro Plan only) | 2 | Per 0.1 MB after included allowance (5-100TB). Applies to LaserStream gRPC and LaserStream WebSocket usage. |
Preconfirmations
Preconfirmations stream transactions over a WebSocket at the lowest possible latency. They are available on all paid plans: Developer, Business, Professional, and Enterprise. Free plans are not eligible. Slots with zero delivered messages cost zero credits, even when the slot has preconfirmation coverage. When a slot delivers at least one message, each openpreconfSubscribe subscription is billed the greater of 300 credits or 10 credits per delivered message. Uncovered slots cost zero.
For example, 0, 10, 30, and 100 delivered messages cost 0, 300, 300, and 1,000 credits respectively. With includeSource: ["helius"], BAM-only covered slots are excluded from billing. regionInclude excludes covered slots outside the selected regions. Eligible slots still cost zero when the subscription receives no messages. See Pricing for every coverage scenario.
Preconfirmations is a new product and pricing is subject to change.
LaserStream WebSocket
LaserStream WebSocket serves the standard Solana subscription methods alongside the Helius-specific extensions (transactionSubscribe, enhanced accountSubscribe) on the unified wss://mainnet.helius-rpc.com endpoint. Standard methods are available on all plans; the Helius extensions require a Developer, Business, or Professional plan. All WebSocket usage is metered at 2 credits per 0.1 MB of uncompressed streamed data.
LaserStream gRPC
LaserStream gRPC Mainnet is available on Business and Professional plans. LaserStream gRPC Devnet is available on all plans. All users pay 2 credits per 0.1 MB of uncompressed streamed data.Preprocessed Transactions
Preprocessed transactions (decoded shreds, ~8 ms ahead ofprocessed) are delivered over the preprocessedSubscribe WebSocket, available on all paid plans and metered at 0.1 credits per message (one message per delivered transaction).
Parsed Streams
Parsed Streams push decoded, server-side filtered transactions over theparsedTransactionSubscribe WebSocket. Available on all plans and metered at 1 credit per delivered event, the same rate as webhook events. Parsed Streams is the successor to Enhanced Transaction Webhooks.
Shred Delivery — Raw Shreds
Raw Shreds (UDP) is our premier, low-latency shred delivery service. You can access raw shreds from your Helius Dashboard. Simply add a seat and enter your IP address to start receiving shreds. Raw shreds do not consume credits. Raw shreds are available to all customers. Each seat is $1,000/month and binds to one IP. If you are on a Professional plan, each seat costs $800/month/IP.Data Add-ons
If you’re on a Professional plan, you may purchase Data Add-ons between 5TB-100TB per month to be used for both LaserStream gRPC and LaserStream WebSocket. Beyond your allowance, streamed data uses your plan credits at 2 credits per 0.1 MB of uncompressed data.Data Size
Billing for data streaming products is based on uncompressed message size. Typical sizes include:- Block (~4MB)
- Account (~0.0004MB)
- Transaction (~0.0006MB)
Transaction Submission Credits
Helius offers two primary transaction submission methods: Sender, our specialized transaction landing service for traders and low-latency applications; and Staked Connections (default) for fast, reliable landing rates.| Method | Credits | Description |
|---|---|---|
| Sender | 0 | Ultra-low latency submission |
| Staked Connections | 1 | Highest reliability (default) |
| sendBundle | 10 | Bundle submission via Jito |
Staked Transactions Are Now Default for All Paid Plans: All transactions via
mainnet.helius-rpc.com automatically use staked connections for highest success rates.DAS API Credits
All DAS API requests cost 10 credits each:Asset Information
getAssetgetAssetProofgetAssetProofBatchgetNftEditions
Asset Discovery
getAssetsByOwnergetAssetsByAuthoritygetAssetsByCreatorgetAssetsByGroupsearchAssetsgetAssetBatch
Transaction History
getSignaturesForAsset
Account Information
getTokenAccounts
Wallet API Credits
All Wallet API requests cost 100 credits each:| Service | Credits | Notes |
|---|---|---|
| Wallet Identity | 100 | Get wallet identity (exchanges, protocols, institutions) |
| Batch Identity Lookup | 100 | Look up up to 100 addresses in a single request |
| Wallet Balances | 100 | Get token and NFT balances with USD values |
| Historical Balance | 100 | Get a token or SOL balance at a past timestamp or slot |
| Wallet History | 100 | Get transaction history with balance changes |
| Token Transfers | 100 | Get all token transfer activity |
| Wallet Funding Source | 100 | Discover who originally funded a wallet |
Wallet-as-a-Service Credits
Wallet-as-a-Service bills through your existing Helius credits — there is no separate subscription and no per-monthly-active-user fee. Each signature costs 200 credits ($0.001 at the standard credit rate), which covers the embedded wallet and signing.| Service | Credits | Notes |
|---|---|---|
| WaaS Signature | 200 | Per signature: signMessage, signTransaction, and signAndSendTransaction each produce one. Billed when the signature is produced, even if the transaction later fails on-chain; signing that never completes (e.g. a cancelled prompt) is free. Wallet creation is free. |
Webhook Credits
| Service | Credits | Notes |
|---|---|---|
| Webhook Events | 1 | Per event sent by Helius, regardless of successful or failed endpoint responses |
| Webhook Management | 100 | Create, edit, delete webhooks |
ZK Compression Credits
All ZK Compression API calls cost 10 credits each. One exception isgetValidityProof which costs 100 credits per request because it is computationally intensive.
| Service | Credits | Notes |
|---|---|---|
| ZK Compression API | 10 | ZK Compression RPC calls |
| getValidityProofs | 100 | Compute ZK proofs |