helius
Skill12 starsChanged 9 months agoMITView on GitHub
Comprehensive guide for Helius - Solana's leading RPC and API infrastructure provider. Covers RPC nodes, DAS (Digital Asset Standard) API, Enhanced Transactions, Priority Fees, Webhooks, ZK Compression, LaserStream gRPC, and the Helius SDK for building high-performance Solana applications
- Reads credentials
- Installs packages
2 other projects use a version of this.
Adopted by
Most recently taken up by
- helius-labs/core-aitheir own version, first seen Nov 13, 2026
- helius-tech-labs/core-aitheir own version, first seen Mar 25, 2026
Other versions2 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 2
- helius-labs/core-ai★ 33same name
- helius-tech-labs/core-ai★ 0same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository81 other files it gives its agents.
- ab-test-setupSkill
- agent-browserSkill
- analytics-trackingSkill
- brainstormingSkill
- browser-useSkill
- c4-architectureSkill
- code-reconSkill
- competitor-alternativesSkill
- copy-editingSkill
- copywritingSkill
- crafting-effective-readmesSkill
- dflowSkill
- drift-protocolSkill
- email-sequenceSkill
- enterprise-readinessSkill
- epub-translateSkill
- example-skillSkill
- form-croSkill
- free-tool-strategySkill
- git-workflowSkill
- hugging-face-cliSkill
- hugging-face-tool-builderSkill
- hugging-face-evaluationSkill
- hugging-face-paper-publisherSkill
- kaminoSkill
- launch-strategySkill
- magicblockSkill
- marketing-ideasSkill
- marketing-psychologySkill
- mermaid-diagramsSkill
- meteoraSkill
- hugging-face-model-trainerSkill
- n8n-code-javascriptSkill
- n8n-code-pythonSkill
- n8n-expression-syntaxSkill
- n8n-mcp-tools-expertSkill
- n8n-node-configurationSkill
- n8n-validation-expertSkill
- n8n-workflow-patternsSkill
- obsidian-vault-managerSkill
- onboarding-croSkill
- openai-knowledgeSkill
- page-croSkill
- paid-adsSkill
- paywall-upgrade-croSkill
- pinocchio-developmentSkill
- popup-croSkill
- pricing-strategySkill
- programmatic-seoSkill
- raydiumSkill
- referral-programSkill
- remotion-best-practicesSkill
- schema-markupSkill
- seo-auditSkill
- signup-flow-croSkill
- skill-boilerplateSkill
- social-contentSkill
- solana-agent-kitSkill
- solana-kit-migrationSkill
- solana-kitSkill
- The first 60 shown.
The file
We split this skill into the rules it gives an agent
6 rules. About 0 are common, 6 are distinctive, and 0 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈6
Distinctive · estimate
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- could be automatic: a setting could enforce it
- Distinctive: line 37
Create an account or sign in
- Distinctive: line 589
Never commit API keys to git
- Distinctive: line 592
Use separate keys for dev/prod
- Distinctive: line 596
Use cursor-based pagination for large datasets
- Distinctive: line 598
Use appropriate commitment levels
- Distinctive: line 603
Use multiple regional endpoints for failover
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Helius Development Guide
Build high-performance Solana applications with Helius - the leading RPC and API infrastructure provider with 99.99% uptime, global edge nodes, and developer-first APIs.
Overview
Helius provides:
- RPC Infrastructure: Globally distributed nodes with ultra-low latency
- DAS API: Unified NFT and token data (compressed & standard)
- Enhanced Transactions: Parsed, human-readable transaction data
- Priority Fee API: Real-time fee recommendations
- Webhooks: Event-driven blockchain monitoring
- ZK Compression: Compressed account and token APIs
- LaserStream: gRPC-based real-time data streaming
- Sender API: Optimized transaction landing
Quick Start
Installation
# Install Helius SDK
npm install helius-sdk
# Or with pnpm (recommended)
pnpm add helius-sdkGet Your API Key
- Visit dashboard.helius.dev
- Create an account or sign in
- Generate an API key
- Store it securely (never commit to git)
Environment Setup
# .env file
HELIUS_API_KEY=your_api_key_hereBasic Setup
import { createHelius } from "helius-sdk";
const helius = createHelius({
apiKey: process.env.HELIUS_API_KEY!,
});
// RPC endpoint URLs
const MAINNET_RPC = `https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`;
const DEVNET_RPC = `https://devnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`;RPC Infrastructure
Endpoints
| Network | HTTP Endpoint | WebSocket Endpoint |
| Mainnet | https://mainnet.helius-rpc.com/?api-key=<KEY> | wss://mainnet.helius-rpc.com/?api-key=<KEY> |
| Devnet | https://devnet.helius-rpc.com/?api-key=<KEY> | wss://devnet.helius-rpc.com/?api-key=<KEY> |
Using with @solana/kit
import { createSolanaRpc, createSolanaRpcSubscriptions } from "@solana/kit";
const rpc = createSolanaRpc(
`https://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`
);
const rpcSubscriptions = createSolanaRpcSubscriptions(
`wss://mainnet.helius-rpc.com/?api-key=${process.env.HELIUS_API_KEY}`
);
// Make RPC calls
const slot = await rpc.getSlot().send();
const balance = await rpc.getBalance(address).send();Helius-Exclusive RPC Methods
| Method | Description |
getProgramAccountsV2 | Cursor-based pagination for program accounts |
getTokenAccountsByOwnerV2 | Efficient token account retrieval |
getTransactionsForAddress | Advanced transaction history with filtering |
// getProgramAccountsV2 - handles large datasets efficiently
const accounts = await helius.rpc.getProgramAccountsV2({
programAddress: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
cursor: null, // Start from beginning
limit: 100,
});
// getTransactionsForAddress - advanced filtering
const transactions = await helius.rpc.getTransactionsForAddress({
address: "wallet_address",
before: null,
until: null,
limit: 100,
source: "JUPITER", // Filter by source
type: "SWAP", // Filter by type
});DAS API (Digital Asset Standard)
Unified access to NFTs, tokens, and compressed assets.
Core Methods
// Get single asset
const asset = await helius.getAsset({
id: "asset_id_here",
});
// Get assets by owner
const assets = await helius.getAssetsByOwner({
ownerAddress: "wallet_address",
page: 1,
limit: 100,
displayOptions: {
showFungible: true,
showNativeBalance: true,
},
});
// Get assets by collection
const collection = await helius.getAssetsByGroup({
groupKey: "collection",
groupValue: "collection_address",
page: 1,
limit: 100,
});
// Search assets with filters
const results = await helius.searchAssets({
ownerAddress: "wallet_address",
tokenType: "fungible",
burnt: false,
page: 1,
limit: 50,
});
// Get batch of assets
const batch = await helius.getAssetBatch({
ids: ["asset1", "asset2", "asset3"],
});
// Get asset proof (for compressed NFTs)
const proof = await helius.getAssetProof({
id: "compressed_nft_id",
});DAS Method Reference
| Method | Description |
getAsset | Get single asset by ID |
getAssetBatch | Get multiple assets |
getAssetProof | Get merkle proof for cNFT |
getAssetProofBatch | Get multiple proofs |
getAssetsByOwner | All assets for wallet |
getAssetsByCreator | Assets by creator address |
getAssetsByAuthority | Assets by authority |
getAssetsByGroup | Assets by collection/group |
searchAssets | Advanced search with filters |
getNftEditions | Get NFT edition info |
getTokenAccounts | Get token accounts |
getSignaturesForAsset | Transaction history for asset |
Enhanced Transactions API
Get parsed, human-readable transaction data.
// Parse transactions by signature
const parsed = await helius.enhanced.getTransactions({
transactions: ["sig1", "sig2", "sig3"],
});
// Get enhanced transaction history
const history = await helius.enhanced.getTransactionsByAddress({
address: "wallet_address",
type: "SWAP", // Optional: filter by type
});Transaction Types
SWAP- DEX swaps (Jupiter, Raydium, Orca)NFT_SALE- NFT marketplace salesNFT_LISTING- NFT listingsNFT_BID- NFT bidsTOKEN_MINT- Token mintingTRANSFER- SOL/token transfersSTAKE- Staking operationsUNKNOWN- Unrecognized transactions
Priority Fee API
Get real-time priority fee recommendations.
// Get priority fee estimate
const feeEstimate = await helius.getPriorityFeeEstimate({
transaction: serializedTransaction, // Base64 encoded
// OR
accountKeys: ["account1", "account2"], // Accounts in transaction
options: {
priorityLevel: "HIGH", // LOW, MEDIUM, HIGH, VERY_HIGH
includeAllPriorityFeeLevels: true,
lookbackSlots: 150,
},
});
console.log(feeEstimate.priorityFeeEstimate); // microLamportsUsing Priority Fees in Transactions
import { getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";
// Get estimate
const { priorityFeeEstimate } = await helius.getPriorityFeeEstimate({
accountKeys: [payer.address, recipient.address],
options: { priorityLevel: "HIGH" },
});
// Add to transaction
const priorityFeeIx = getSetComputeUnitPriceInstruction({
microLamports: BigInt(priorityFeeEstimate),
});
// Prepend to transaction instructions
const tx = pipe(
createTransactionMessage({ version: 0 }),
(tx) => setTransactionMessageFeePayer(payer.address, tx),
(tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
(tx) => prependTransactionMessageInstructions([priorityFeeIx], tx),
(tx) => appendTransactionMessageInstruction(mainInstruction, tx),
);Webhooks
Real-time blockchain event notifications.
Webhook Types
| Type | Description |
| Enhanced | Parsed, filtered events (NFT sales, swaps, etc.) |
| Raw | Unfiltered transaction data, lower latency |
| Discord | Direct Discord channel notifications |
Create Webhook
// Create enhanced webhook
const webhook = await helius.webhooks.createWebhook({
webhookURL: "https://your-server.com/webhook",
transactionTypes: ["NFT_SALE", "SWAP"],
accountAddresses: ["address1", "address2"],
webhookType: "enhanced",
});
// Create raw webhook
const rawWebhook = await helius.webhooks.createWebhook({
webhookURL: "https://your-server.com/raw-webhook",
accountAddresses: ["address1"],
webhookType: "raw",
});Manage Webhooks
// Get all webhooks
const webhooks = await helius.webhooks.getAllWebhooks();
// Get specific webhook
const webhook = await helius.webhooks.getWebhookByID({
webhookID: "webhook_id",
});
// Update webhook
await helius.webhooks.updateWebhook({
webhookID: "webhook_id",
webhookURL: "https://new-url.com/webhook",
accountAddresses: ["address1", "address2", "address3"],
});
// Delete webhook
await helius.webhooks.deleteWebhook({
webhookID: "webhook_id",
});Webhook Payload (Enhanced)
interface EnhancedWebhookPayload {
accountData: AccountData[];
description: string;
events: Record<string, unknown>;
fee: number;
feePayer: string;
nativeTransfers: NativeTransfer[];
signature: string;
slot: number;
source: string;
timestamp: number;
tokenTransfers: TokenTransfer[];
type: string;
}ZK Compression API
Work with compressed accounts and tokens (Light Protocol).
// Get compressed account
const account = await helius.zk.getCompressedAccount({
address: "compressed_account_address",
});
// Get compressed token accounts by owner
const tokens = await helius.zk.getCompressedTokenAccountsByOwner({
owner: "wallet_address",
});
// Get compressed balance
const balance = await helius.zk.getCompressedBalance({
address: "compressed_account_address",
});
// Get validity proof
const proof = await helius.zk.getValidityProof({
hashes: ["hash1", "hash2"],
});
// Get compression signatures
const sigs = await helius.zk.getCompressionSignaturesForOwner({
owner: "wallet_address",
limit: 100,
});ZK Compression Methods
| Method | Description |
getCompressedAccount | Get compressed account data |
getCompressedAccountProof | Get proof for account |
getCompressedAccountsByOwner | All compressed accounts for wallet |
getCompressedBalance | Get compressed SOL balance |
getCompressedTokenAccountsByOwner | Compressed token accounts |
getCompressedTokenBalancesByOwner | Token balances |
getValidityProof | Get validity proof for hashes |
getCompressionSignaturesForOwner | Compression transaction history |
getIndexerHealth | Check indexer status |
getIndexerSlot | Current indexed slot |
Transaction Sending
Smart Transaction Sending
// Send with automatic retry and optimization
const signature = await helius.tx.sendSmartTransaction({
transaction: signedTransaction,
skipPreflight: false,
maxRetries: 3,
});
// Estimate compute units
const computeUnits = await helius.tx.getComputeUnits({
transaction: serializedTransaction,
});Optimized Transaction Pattern
import { createHelius } from "helius-sdk";
import {
pipe,
createTransactionMessage,
setTransactionMessageFeePayer,
setTransactionMessageLifetimeUsingBlockhash,
appendTransactionMessageInstruction,
signTransactionMessageWithSigners,
getBase64EncodedWireTransaction,
} from "@solana/kit";
import {
getSetComputeUnitLimitInstruction,
getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";
async function sendOptimizedTransaction(
helius: ReturnType<typeof createHelius>,
rpc: Rpc,
signer: KeyPairSigner,
instruction: IInstruction
) {
// 1. Get priority fee
const { priorityFeeEstimate } = await helius.getPriorityFeeEstimate({
accountKeys: [signer.address],
options: { priorityLevel: "HIGH" },
});
// 2. Get blockhash
const { value: blockhash } = await rpc.getLatestBlockhash().send();
// 3. Build transaction with compute budget
const tx = pipe(
createTransactionMessage({ version: 0 }),
(tx) => setTransactionMessageFeePayer(signer.address, tx),
(tx) => setTransactionMessageLifetimeUsingBlockhash(blockhash, tx),
(tx) => prependTransactionMessageInstructions([
getSetComputeUnitLimitInstruction({ units: 200_000 }),
getSetComputeUnitPriceInstruction({ microLamports: BigInt(priorityFeeEstimate) }),
], tx),
(tx) => appendTransactionMessageInstruction(instruction, tx),
);
// 4. Sign
const signedTx = await signTransactionMessageWithSigners(tx);
// 5. Send via Helius
const signature = await helius.tx.sendSmartTransaction({
transaction: getBase64EncodedWireTransaction(signedTx),
});
return signature;
}WebSocket Subscriptions
Real-time data streaming via WebSocket.
// Subscribe to account changes
const accountSub = await helius.ws.accountNotifications({
account: "account_address",
commitment: "confirmed",
callback: (notification) => {
console.log("Account changed:", notification);
},
});
// Subscribe to logs
const logsSub = await helius.ws.logsNotifications({
filter: { mentions: ["program_id"] },
commitment: "confirmed",
callback: (logs) => {
console.log("Logs:", logs);
},
});
// Subscribe to signature confirmations
const sigSub = await helius.ws.signatureNotifications({
signature: "transaction_signature",
commitment: "confirmed",
callback: (status) => {
console.log("Confirmed:", status);
},
});
// Unsubscribe
await accountSub.unsubscribe();LaserStream (gRPC)
High-performance data streaming for institutional use.
Features
- Redundant node clusters
- Historical replay capability
- Regional endpoints (FRA, AMS, TYO, SG, LAX, LON, EWR, PITT, SLC)
- Block, transaction, and account streaming
Endpoints
| Region | Endpoint |
| Frankfurt | fra.laserstream.helius.dev |
| Amsterdam | ams.laserstream.helius.dev |
| Tokyo | tyo.laserstream.helius.dev |
| Singapore | sg.laserstream.helius.dev |
| Los Angeles | lax.laserstream.helius.dev |
Staking API
Stake SOL with Helius validator programmatically.
// Create stake transaction
const stakeTx = await helius.staking.createStakeTransaction({
payerAddress: "wallet_address",
amount: 1_000_000_000, // 1 SOL in lamports
});
// Create unstake transaction
const unstakeTx = await helius.staking.createUnstakeTransaction({
payerAddress: "wallet_address",
stakeAccountAddress: "stake_account",
});
// Get stake accounts
const stakeAccounts = await helius.staking.getHeliusStakeAccounts({
ownerAddress: "wallet_address",
});SDK Namespaces
| Namespace | Purpose |
helius.* | DAS API, priority fees |
helius.rpc.* | Enhanced RPC methods |
helius.tx.* | Transaction operations |
helius.staking.* | Validator staking |
helius.enhanced.* | Decoded transaction data |
helius.webhooks.* | Event management |
helius.ws.* | WebSocket subscriptions |
helius.zk.* | ZK Compression features |
Error Handling
try {
const assets = await helius.getAssetsByOwner({ ownerAddress: "..." });
} catch (error) {
if (error.response?.status === 401) {
console.error("Invalid API key");
} else if (error.response?.status === 429) {
console.error("Rate limited - upgrade plan or reduce requests");
} else if (error.response?.status >= 500) {
console.error("Helius server error - retry later");
}
}Common Error Codes
| Code | Meaning | Solution |
| 401 | Invalid API key | Check key in dashboard |
| 429 | Rate limited | Upgrade plan or add delays |
| 500+ | Server error | Retry with backoff |
Rate Limits & Pricing
| Plan | Credits/Month | RPC Calls | Webhooks |
| Free | 500,000 | Standard | 2 |
| Developer | 5M | Enhanced | 10 |
| Growth | 50M | Priority | 50 |
| Enterprise | Custom | Dedicated | Unlimited |
Credit Costs
- Standard RPC: 1 credit/call
- DAS API: 1-10 credits/call
- Webhooks: 1 credit/event delivered
- Webhook management: 100 credits/operation
Best Practices
API Key Security
- Never commit API keys to git
- Use environment variables
- Rotate keys periodically
- Use separate keys for dev/prod
Performance
- Batch requests when possible (getAssetBatch, getAssetProofBatch)
- Use cursor-based pagination for large datasets
- Cache frequently accessed data
- Use appropriate commitment levels
Reliability
- Implement retry logic with exponential backoff
- Handle rate limits gracefully
- Use multiple regional endpoints for failover
- Monitor webhook delivery and handle retries
Resources
Skill Structure
helius/
├── SKILL.md # This file
├── resources/
│ ├── rpc-methods.md # Complete RPC reference
│ ├── das-api.md # DAS API reference
│ ├── enhanced-apis.md # Enhanced transactions & priority fees
│ ├── webhooks.md # Webhook configuration
│ ├── zk-compression.md # ZK compression API
│ └── sdk-reference.md # SDK namespace reference
├── examples/
│ ├── basic-rpc/ # Basic RPC calls
│ ├── fetch-nfts/ # DAS API examples
│ ├── send-transactions/ # Transaction sending
│ ├── webhooks/ # Webhook setup
│ └── streaming/ # Real-time data
├── templates/
│ └── helius-setup.ts # Starter template
└── docs/
└── troubleshooting.md # Common issuesDoes it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

