If you're building on Solana, you've almost certainly heard of Helius. It's become the de facto RPC and API provider for serious Solana developers — used by some of the largest protocols in the ecosystem, from trading tools to NFT platforms to DeFi dashboards.
Helius does more than just serve RPC requests. It offers enhanced transaction data, webhook notifications, the Digital Asset Standard (DAS) API for NFTs and compressed tokens, token metadata APIs, and transaction parsing that turns raw Solana data into human-readable events.
This guide walks through every major Helius feature with practical examples.
What Is Helius?
Helius is a Solana infrastructure company providing:
- RPC nodes: Fast, reliable Solana RPC endpoints for your apps
- Enhanced APIs: Enriched blockchain data beyond standard Solana RPC
- Webhooks: Real-time notifications for on-chain events
- DAS API: Standardized access to NFTs, compressed NFTs (cNFTs), and Token-2022 assets
- Transaction parsing: Human-readable summaries of complex Solana transactions
- Token metadata: Name, symbol, logo, and other data for any SPL token
Helius is based in San Francisco and has raised significant venture backing. It serves millions of RPC requests daily for hundreds of Solana applications.
Getting Started: Creating a Helius Account
- Go to helius.dev and sign up with your email
- Create a new project — give it a name (e.g., "My Solana App")
- Helius generates an API key for your project
- You get a dedicated RPC URL:
https://mainnet.helius-rpc.com/?api-key=YOUR_KEY
The free tier includes 100,000 credits/month, which is enough for development and small projects. Paid plans scale for production usage.
Using Helius as Your Solana RPC
The most basic use case: replace a public RPC endpoint with your Helius endpoint for better reliability and speed.
In JavaScript/TypeScript
import { Connection } from "@solana/web3.js";
const connection = new Connection(
"https://mainnet.helius-rpc.com/?api-key=YOUR_KEY",
"confirmed"
);
// Works exactly like any Solana Connection
const slot = await connection.getSlot();
const balance = await connection.getBalance(walletPublicKey);
In a Next.js app
// src/lib/solana.ts
import { Connection } from "@solana/web3.js";
export const heliusConnection = new Connection(
process.env.HELIUS_RPC_URL!,
"confirmed"
);
Store your API key in .env.local as HELIUS_RPC_URL=https://mainnet.helius-rpc.com/?api-key=YOUR_KEY.
Why Helius RPC over public endpoints
| Factor | Public RPC | Helius |
|---|
| Rate limits | Aggressive | Generous (paid plans) |
| Uptime | Variable | 99.9%+ SLA |
| Speed | Shared, slow | Dedicated infrastructure |
| Enhanced data | No | Yes |
| Support | None | Discord + docs |
For production apps, public RPCs will rate-limit you into oblivion during high traffic. Helius handles load that would kill public endpoints.
Enhanced Transaction Parsing
One of Helius's most powerful features: parseTransactions. Instead of decoding raw Solana transaction instructions yourself, Helius returns a clean JSON object describing what happened.
API call
const response = await fetch(
"https://api.helius.xyz/v0/transactions/?api-key=YOUR_KEY",
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
transactions: ["5UfDuX4xVnnLSBr9...your_tx_signature"],
}),
}
);
const parsed = await response.json();
Example output
{
"type": "SWAP",
"description": "User swapped 1.5 SOL for 143.2 USDC on Jupiter",
"source": "JUPITER",
"feePayer": "7xKX...",
"tokenTransfers": [
{ "fromUserAccount": "7xKX...", "toUserAccount": "...", "tokenAmount": 1.5 },
{ "fromUserAccount": "...", "toUserAccount": "7xKX...", "tokenAmount": 143.2 }
]
}
Instead of decoding instruction data manually, you get a human-readable description of every supported transaction type: swaps, NFT sales, staking events, token transfers, liquidity events, and more.
Supported transaction types include:
SWAP — DEX trades across Jupiter, Raydium, OrcaNFT_SALE — Magic Eden, Tensor, OpenSeaNFT_MINT — Candy Machine mintsSTAKE_SOL — Staking delegationTRANSFER — Token and SOL transfersDeFi events — Lending deposits/withdrawals, LP adds/removes
Webhooks: Real-Time On-Chain Alerts
Webhooks let you receive HTTP POST requests whenever specific on-chain events happen. This is how you build real-time apps without polling.
Creating a Webhook
Via the Helius dashboard:
-
Go to Webhooks in your project
-
Click New Webhook
-
Enter your endpoint URL (e.g., https://yourapp.com/api/webhook)
-
Choose the webhook type:
- Address Activity: Fires when a specific wallet address is involved in any transaction
- Token Activity: Fires when a specific token is transferred
- NFT Events: Fires for sales, listings, mints of specific collections
- Program Activity: Fires when a specific smart contract is called
-
Add wallet addresses, token mints, or program IDs to watch
-
Save
Example: Watch a wallet for any activity
// POST to https://api.helius.xyz/v0/webhooks?api-key=YOUR_KEY
{
"webhookURL": "https://yourapp.com/api/wallet-alert",
"transactionTypes": ["Any"],
"accountAddresses": ["7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsf"],
"webhookType": "enhanced"
}
Handling the webhook in Next.js
// src/app/api/wallet-alert/route.ts
export async function POST(req: Request) {
const events = await req.json();
for (const event of events) {
console.log(`Transaction: ${event.type} — ${event.description}`);
// Send notification, update database, trigger automation
}
return Response.json({ ok: true });
}
Webhooks are how serious apps avoid burning RPC credits on polling. Instead of checking a wallet every 5 seconds, Helius pushes data to you the moment something happens.
DAS API: NFTs and Compressed Tokens
The Digital Asset Standard (DAS) API is the industry standard for accessing NFT and compressed NFT data on Solana. It handles regular NFTs, Metaplex NFTs, Token-2022 assets, and compressed NFTs (cNFTs).
Get all assets owned by a wallet
const response = await fetch(
"https://mainnet.helius-rpc.com/?api-key=YOUR_KEY",
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
id: "get-assets",
method: "getAssetsByOwner",
params: {
ownerAddress: "7xKXtg2CW87d97TXJSDpbD5jBkheTqA83TZRuJosgAsf",
page: 1,
limit: 100,
displayOptions: { showFungible: true }
}
})
}
);
Get metadata for a specific NFT
{
"jsonrpc": "2.0",
"id": "get-asset",
"method": "getAsset",
"params": { "id": "THE_NFT_MINT_ADDRESS" }
}
Returns name, description, image URL, attributes, current owner, collection, royalty info, and compression data — everything you need to display or analyze an NFT.
Token Metadata API
Get name, symbol, logo, and decimals for any SPL token:
const response = await fetch(
`https://api.helius.xyz/v0/token-metadata?api-key=YOUR_KEY`,
{
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
mintAccounts: [
"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", // USDC
"So11111111111111111111111111111111111111112" // Wrapped SOL
]
})
}
);
Returns symbol, name, logo URL, supply, and decimals for each mint. Essential for any app that displays token info.
Helius Free Tier vs Paid Plans
| Feature | Free | Developer | Business |
|---|
| Monthly credits | 100K | 5M | Custom |
| Webhooks | 1 | 10 | Unlimited |
| RPC requests | Included | Included | Dedicated |
| Support | Docs | Discord | Priority |
| Enhanced APIs | Yes | Yes | Yes |
For most side projects and MVPs, the free tier is sufficient. Production apps with real traffic will need a paid plan.
Best Practices
- Cache responses: Don't hit the API for the same data repeatedly. Cache token metadata, NFT data, and other slow-changing data
- Use webhooks, not polling: For real-time data, webhooks are more efficient and don't burn credits
- Handle rate limits: Implement exponential backoff in case you hit rate limits
- Keep API keys server-side: Never expose your Helius API key in client-side code
- Use the DAS API for all asset data: It's the most complete and standardized way to access NFT and token data
Helius vs Other Solana RPC Providers
| Provider | Strengths | Weaknesses |
|---|
| Helius | Enhanced APIs, webhooks, DAS API, parsing | Costs more at scale |
| QuickNode | Multi-chain, enterprise features | Less Solana-specific tooling |
| Alchemy | Broad ecosystem, reliability | Solana support less mature |
| Triton | Very fast, gRPC streaming | Developer experience |
| Public RPCs | Free | Rate-limited, unreliable |
For Solana-specific development, Helius is the strongest choice because of its Solana-native features. Compare all options in the Solana RPC providers guide.
Summary
Helius is more than an RPC provider — it's a complete Solana developer infrastructure platform. The combination of reliable RPC, real-time webhooks, transaction parsing, and the DAS API makes it the fastest way to build production-ready Solana apps without reinventing the wheel.
Start with the free tier to learn the APIs, then scale to a paid plan when your app requires it. The Helius documentation is comprehensive and actively maintained.
Explore all Solana API and developer tools on MadeOnSol.
