Helius is Solana's leading developer infrastructure platform. This guide covers how to use Helius RPC for your dApp, set up webhooks for real-time on-chain alerts, use the DAS API for NFT data, and parse Solana transactions — with code examples.
Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.
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.
Helius is a Solana infrastructure company providing:
Helius is based in San Francisco and has raised significant venture backing. It serves millions of RPC requests daily for hundreds of Solana applications.
https://mainnet.helius-rpc.com/?api-key=YOUR_KEYThe free tier includes 100,000 credits/month, which is enough for development and small projects. Paid plans scale for production usage.
The most basic use case: replace a public RPC endpoint with your Helius endpoint for better reliability and speed.
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);
// src/lib/solana.ts
import { Connection } from "@solana/web3.js";
export const heliusConnection = new Connection(
process.env.HELIUS_RPC_URL!,
"confirmed"
);
Building a product on Solana data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
Build with MadeOnSol API
KOL tracking, deployer intelligence, DEX streaming, and webhooks. Free API key — 200 requests/day.
import { MadeOnSol } from "madeonsol";
// Get a free API key at madeonsol.com/pricing
const client = new MadeOnSol({ apiKey: "msk_your_key" });
const { trades } = await client.kol.feed({ limit: 10 });
const { alerts } = await client.deployer.alerts({ limit: 5 });
const { tools } = await client.tools.search({ q: "trading" });Building a product on Solana data?
MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.
Signals you'd otherwise build
KOL & smart-money flow from 2,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 10 WS + 5 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Developer Tools
Understand what Solana APIs are, what types exist, and how developers use them to build trading bots, portfolio trackers, and analytics dashboards. Covers RPC, enhanced APIs, data APIs, and when to use each.
Developer Tools
Paste a mint into Telegram, get a scored rug-risk report back in seconds. This tutorial walks the open-source rug-check-telegram-bot starter: zero dependencies, ~150 lines of Node, a free MadeOnSol API key, and a transparent 0–100 score where every point is attributed to a named factor — mint authority, liquidity depth, LP burn, bundled launch, deployer track record.
Developer Tools
You can embed a Solana data API in your app on a standard plan — but the moment you resell the data, expose it as your own feed, or strip the branding, you're in licensing territory most builders discover too late. This guide maps the three usage zones (internal use, user-facing display, redistribution), the questions to ask any data vendor before you build, and what an Enterprise data license actually covers: white-label, bulk export, extended caching, SLA, and dedicated limits.
Developer Tools
Get a Discord embed the moment a proven Solana deployer — one with a real bonding track record on pump.fun or LaunchLab — launches a new token or one of their tokens bonds. This tutorial walks the open-source deployer-alert-discord-bot starter: zero dependencies, ~130 lines, a Discord webhook, and a free MadeOnSol API key.
Developer Tools
Watch live smart-money trades on Solana and paper-trade them in real time: open a virtual position when a tracked KOL buys, close when they sell, and track PnL from the market-cap multiple. This tutorial walks the open-source kol-copytrade-bot-starter — ~300 lines, one dependency, free API key — and shows how to filter by KOL win rate, deployer tier, and multi-KOL confirmation before risking anything real.
Developer Tools
An AI agent is only as sharp as the data it can reach. This guide compares the three ways to wire live Solana memecoin intelligence — KOL flow, rug scores, deployer reputation — into an agent: the MCP server for Claude and Cursor, the solana-agent-kit plugin for autonomous JS agents, and x402 micropayments where the agent's wallet IS the API key. With the decision table, code-free setup for each, and the safety line that matters: the data layer never executes trades.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana & Robinhood Chain tools — free to explore.
Open the KOL TrackerStore your API key in .env.local as HELIUS_RPC_URL=https://mainnet.helius-rpc.com/?api-key=YOUR_KEY.
| 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.
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.
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();
{
"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/removesWebhooks let you receive HTTP POST requests whenever specific on-chain events happen. This is how you build real-time apps without polling.
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:
Add wallet addresses, token mints, or program IDs to watch
Save
// 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"
}
// 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. For the broader picture of how on-chain webhooks fit into an alerting stack, see our complete guide to Solana webhooks and real-time alerts.
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).
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 }
}
})
}
);
{
"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.
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.
| 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.
| 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.
Yes. Helius offers a free tier with 100,000 credits per month, one webhook, and access to all enhanced APIs including DAS, transaction parsing, and token metadata. It's enough for development and small projects. Paid plans start at $49/month for higher rate limits and more credits.
The Digital Asset Standard (DAS) API is Helius's interface for accessing NFT, compressed NFT (cNFT), and Token-2022 asset data on Solana. It lets you query all assets owned by a wallet, get metadata for specific NFTs, and handle compressed tokens — all through a standardized JSON-RPC interface.
Public RPCs are rate-limited (roughly 40 requests/second), have no SLA, and lack enhanced features. Helius provides dedicated infrastructure with 99.9%+ uptime, higher rate limits, plus Solana-specific features like transaction parsing, webhooks, DAS API, and priority fee estimation that public endpoints don't offer.
Yes. Helius is one of the most popular choices for Solana trading bots. Its staked connections improve transaction landing rates, the priority fee API helps optimize fees, and webhooks provide real-time notifications without polling. The Business tier ($499/month) with 200 req/sec and staked connections is the typical choice for active bots.
No. Helius is Solana-only. If you need multi-chain RPC support, consider QuickNode (30+ chains) or Alchemy (multiple chains). For Solana-specific development, Helius's focused approach means deeper features than multi-chain providers.
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. For the manual, no-code side of transaction lookups, see our Solscan guide.