# Helius — Full Agent Context > Helius is Solana's leading infrastructure provider and developer platform. From high-performance RPC nodes and transaction sending (Sender) to gRPC streaming (LaserStream), webhooks, and digital asset APIs — Helius powers teams like Phantom, Jupiter, DFlow, Coinbase, and Bitwise. This file aggregates the agent-readable surfaces on helius.dev into one document so an agent can ingest the full context in a single request. After the agent surfaces, every marketing, comparison and use-case page is inlined via its markdown twin (the same content served at that page's `.md` URL), followed by the blog index listing every published post. For a navigation-only directory, see https://www.helius.dev/llms.txt. For narrower section-level indexes, see https://www.helius.dev/blog/llms.txt, https://www.helius.dev/use-case/llms.txt, https://www.helius.dev/staking/llms.txt, https://www.helius.dev/parsed-data/llms.txt, https://www.helius.dev/api/llms.txt, https://www.helius.dev/docs/llms.txt. --- ## Agent Onboarding _Source: https://www.helius.dev/AGENTS.md_ > Helius is Solana's leading infrastructure provider and developer platform — RPC nodes, transaction sending (Sender), gRPC streaming (LaserStream), webhooks, and digital asset APIs. This file is a focused onboarding document for autonomous agents (Claude, Cursor, Codex, custom). For the full machine-readable index, see [/llms.txt](https://www.helius.dev/llms.txt). ## Quick Start ```bash # 1. Get an API key (requires a valid email + name; $10 USDC one-time on Solana mainnet) npx helius-cli signup --email you@example.com --first-name Jane --last-name Doe --json # → open the returned paymentUrl and pay with any wallet, then: npx helius-cli signup --resume --json # 2. Or get one interactively open https://dashboard.helius.dev # 3. Run the MCP server (works with any MCP-compatible client) npx helius-mcp@latest ``` Set `HELIUS_API_KEY` from the dashboard or the CLI signup output. ## API Surfaces Each surface has a per-API OpenAPI spec at `https://www.helius.dev/openapi/.json`. The merged catalog is at [/openapi.json](https://www.helius.dev/openapi.json) and the RFC 9727 linkset is at [/.well-known/api-catalog](https://www.helius.dev/.well-known/api-catalog). | Surface | Endpoint | Spec | Docs | | ------------------------------------- | ------------------------------------ | ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | | Solana RPC (HTTP) + Helius extensions | `https://mainnet.helius-rpc.com` | [rpc-http.json](https://www.helius.dev/openapi/rpc-http.json) | [/docs/rpc/guides/overview](https://www.helius.dev/docs/rpc/guides/overview) | | Digital Asset Standard (DAS) | `https://mainnet.helius-rpc.com` | [das-api.json](https://www.helius.dev/openapi/das-api.json) | [/docs/das-api](https://www.helius.dev/docs/das-api) | | Sender (transaction submission) | `https://sender.helius-rpc.com` (global HTTPS, frontend) or `http://{region}-sender.helius-rpc.com` (regional HTTP, backend: `slc`, `ewr`, `lon`, `fra`, `ams`, `sg`, `tyo`) | [sender-api.json](https://www.helius.dev/openapi/sender-api.json) | [/docs/sending-transactions/sender](https://www.helius.dev/docs/sending-transactions/sender) | | Wallet API | `https://api.helius.xyz/v1/wallet` | [wallet-api.json](https://www.helius.dev/openapi/wallet-api.json) | [/docs/wallet-api/overview](https://www.helius.dev/docs/wallet-api/overview) | | Priority Fee | `https://mainnet.helius-rpc.com` | [priority-fee-api.json](https://www.helius.dev/openapi/priority-fee-api.json) | [/docs/priority-fee-api](https://www.helius.dev/docs/priority-fee-api) | | ZK Compression Indexer | `https://mainnet.helius-rpc.com` | [zk-compression.json](https://www.helius.dev/openapi/zk-compression.json) | [/docs/zk-compression/introduction](https://www.helius.dev/docs/zk-compression/introduction) | | Admin (project usage, billing) | `https://admin-api.helius.xyz` | [admin-api.json](https://www.helius.dev/openapi/admin-api.json) | [/docs/api-reference/admin](https://www.helius.dev/docs/api-reference/admin) | | Webhooks | `https://api.helius.xyz/v0/webhooks` | [webhooks.json](https://www.helius.dev/openapi/webhooks.json) | [/docs/webhooks](https://www.helius.dev/docs/webhooks) | | LaserStream (gRPC streaming) | `https://laserstream-{network}-{region}.helius-rpc.com` (mainnet regions: `slc`, `ewr`, `lon`, `fra`, `ams`, `sgp`, `tyo`, `lax`, `pitt`; devnet: `ewr`). Auth: `x-token` gRPC metadata header. | gRPC, no OpenAPI — SDK: [helius-labs/laserstream-sdk](https://github.com/helius-labs/laserstream-sdk) | [/docs/laserstream/grpc](https://www.helius.dev/docs/laserstream/grpc) | ## Errors & Retries - **Auth:** every surface requires an `api-key` query parameter (e.g. `?api-key=YOUR_KEY`). A missing or invalid key returns `401`. - **Rate limits:** `429` means you exceeded your plan's RPS or credit budget. Back off and honor the `Retry-After` header when present. Per-plan limits are at [/pricing.md](https://www.helius.dev/pricing.md). - **Transient failures:** retry `429` and `5xx` with exponential backoff (e.g. 2s, 4s, 8s; ~3 attempts). Do not retry `400`/`401`/`404` — those are permanent and need a fixed request. - **CLI:** `helius` commands emit distinct exit codes per error class and, with `--json`, a `{ error, message, retryable }` body — see [/cli.md](https://www.helius.dev/cli.md). The full auth/error/revocation contract is at [/auth.md](https://www.helius.dev/auth.md). - **Live status:** [helius.statuspage.io](https://helius.statuspage.io/) — check here before retrying if calls fail broadly. ## MCP Server Helius ships a stdio MCP server distributed via npm. It exposes 10 routed tools covering 60+ Solana operations: RPC, DAS, parsed transactions, wallet intelligence, webhooks, Laserstream, priority fees, staking, and onchain API key signup. - Install + run: `npx helius-mcp@latest` - Server card: [/.well-known/mcp-server-card](https://www.helius.dev/.well-known/mcp-server-card) - Source: [helius-labs/core-ai/helius-mcp](https://github.com/helius-labs/core-ai/tree/main/helius-mcp) - Docs: [/docs/agents/mcp](https://www.helius.dev/docs/agents/mcp) The server is verified and listed in [Anthropic's Claude Code plugin marketplace](https://github.com/anthropics/claude-plugins-official). Install in Claude Code: `/plugin marketplace add helius-labs/core-ai && /plugin install helius@helius-labs`. ## Discovery Surfaces | Path | Purpose | | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------- | | [/llms.txt](https://www.helius.dev/llms.txt) | Broad markdown index of pages, posts, APIs, and agent surfaces | | [/openapi.json](https://www.helius.dev/openapi.json) | Merged OpenAPI 3.1 catalog across all REST surfaces | | [/.well-known/api-catalog](https://www.helius.dev/.well-known/api-catalog) | RFC 9727 linkset enumerating each API | | [/.well-known/agent-card.json](https://www.helius.dev/.well-known/agent-card.json) | A2A-compatible agent card | | [/.well-known/mcp-server-card](https://www.helius.dev/.well-known/mcp-server-card) | SEP-2127 MCP server card | | [/api/agents.md](https://www.helius.dev/api/agents.md) | Step-by-step CLI signup flow for autonomous API key acquisition | | [/api/agents.json](https://www.helius.dev/api/agents.json) | Same signup flow, machine-readable | | [/?mode=agent](https://www.helius.dev/?mode=agent) | Structured JSON summary of every agent-facing surface on the site | Most pages also advertise a markdown alternate via `Link: <...>; rel="alternate"; type="text/markdown"`. Append `.md` to a page URL or send `Accept: text/markdown` to fetch the markdown variant. ## Repos - [helius-labs/core-ai](https://github.com/helius-labs/core-ai) — monorepo for the MCP server, Claude Code plugin, agent skills, and CLI - [MCP server](https://github.com/helius-labs/core-ai/tree/main/helius-mcp) — 10 routed tools covering 60+ Solana operations for any MCP client; `npx helius-mcp@latest` (npm: `helius-mcp`) - [Claude Code plugin](https://github.com/helius-labs/core-ai/tree/main/helius-plugin) — verified in Anthropic's official marketplace; `/plugin marketplace add helius-labs/core-ai && /plugin install helius@helius-labs` - [Agent skills](https://github.com/helius-labs/core-ai/tree/main/helius-skills) — helius, helius-phantom, helius-jupiter, helius-okx, helius-dflow, svm — also comes bundled with the plugin - [helius-cli](https://github.com/helius-labs/core-ai/tree/main/helius-cli) — CLI used by the autonomous signup flow above; `npm install -g helius-cli` (npm: `helius-cli`) - [helius-labs/helius-sdk](https://github.com/helius-labs/helius-sdk) — TypeScript SDK (npm: `helius-sdk`) - [helius-labs/helius-rust-sdk](https://github.com/helius-labs/helius-rust-sdk) — Rust SDK (crates.io: `helius`) ## Support - Docs: [/docs](https://www.helius.dev/docs) - Status: [helius.statuspage.io](https://helius.statuspage.io/) - Support: support@helius.xyz · [/docs/support/contact-support](https://www.helius.dev/docs/support/contact-support) - Sales / partnerships: [/contact](https://www.helius.dev/contact) --- ## Agent Signup Flow _Source: https://www.helius.dev/api/agents.md_ > Machine-readable instructions for AI agents to obtain a Helius API key via CLI. ## Quick Reference | Requirement | Value | |-------------|-------| | Contact info | **Required:** a valid email, first name, and last name (`--email`, `--first-name`, `--last-name`) | | Cost | $10 USDC one-time (Agent plan, 1,000,000 credits; also returned as `amountCents`) | | Payment | Hosted payment link (pay from any wallet), or autopay USDC from the local keypair (`--pay`) | | Network | Solana Mainnet | | CLI Install | `npm install -g helius-cli` | | Output Format | JSON envelope (use `--json` flag) | ## Prerequisites 1. Node.js 20+ installed 2. A valid email address, first name, and last name for the account owner. Signup is refused without them. 3. Only for autopay (`--pay`): a Solana wallet funded with 10 USDC (mainnet) plus ~0.001 SOL for transaction fees. The hosted payment link needs no local funding. ## Complete Flow ### Step 1: Install CLI ```bash npm install -g helius-cli ``` ### Step 2: Generate Keypair ```bash helius keygen ``` **Output:** Creates keypair at `~/.helius/keypair.json` **Returns:** Wallet address. This wallet identifies the account; with `--pay` it also funds the payment. ### Step 3: Create a Payment Intent ```bash helius signup --email you@example.com --first-name Jane --last-name Doe --json ``` `--email`, `--first-name`, and `--last-name` are required for every new signup, including the Agent plan (the default `--plan`). **Response (`data.status: "PAYMENT_REQUIRED"`):** ```json { "ok": true, "v": 1, "data": { "status": "PAYMENT_REQUIRED", "paymentUrl": "https://dashboard.helius.dev/pay/", "paymentIntentId": "", "walletAddress": "YourWalletAddress...", "refId": "...", "expiresAt": "2026-01-01T00:00:00.000Z", "amountCents": 1000, "planName": "Agent Plan", "destinationWallet": "TreasuryAddress...", "memo": "...", "solanaPayUrl": "solana:..." } } ``` The pending intent is saved to `~/.helius/config.json`. ### Step 4: Pay Pick one: - **Hosted link (default):** open `data.paymentUrl` in a browser and pay with any wallet. Nothing needs to be funded locally. - **Autopay:** fund the keypair from Step 2 with 10 USDC (`amountCents / 100`) plus ~0.001 SOL, then run: ```bash helius signup --plan agent --pay --email you@example.com --first-name Jane --last-name Doe --json ``` `--pay` reuses the pending intent from Step 3, sends USDC + memo from the local keypair, and polls until the account is provisioned. ### Step 5: Finalize and Get API Key After paying via the hosted link, run: ```bash helius signup --resume --json ``` **Success Response (exit code 0):** ```json { "ok": true, "v": 1, "data": { "status": "SUCCESS", "walletAddress": "YourWalletAddress...", "projectId": "project-uuid", "apiKey": "your-api-key-here", "endpoints": { "mainnet": "https://mainnet.helius-rpc.com/?api-key=your-api-key-here", "devnet": "https://devnet.helius-rpc.com/?api-key=your-api-key-here" }, "paymentIntentId": "", "txSignature": "transaction-signature-or-null" } } ``` **Extract API key:** `response.data.apiKey` **Extract RPC URL:** `response.data.endpoints.mainnet` or `response.data.endpoints.devnet` If the payment is still confirming, `data.status` is `PENDING`; run `helius signup --resume --json` again shortly. `EXPIRED` or `FAILED` means the intent is gone; start over with `helius signup` (add `--restart` to discard a stored intent). ## Signup Statuses | `data.status` | Meaning | Next step | |---------------|---------|-----------| | `PAYMENT_REQUIRED` | Payment intent created (or reused) | Pay via `paymentUrl`, or re-run with `--pay` | | `PENDING` | Payment not yet confirmed | Re-run `helius signup --resume --json` | | `SUCCESS` | Account provisioned | Extract `apiKey` and `endpoints` | | `ALREADY_SUBSCRIBED` | Wallet already has a project on this plan | Extract `apiKey` and `endpoints` (no new charge) | | `UPGRADE_REQUIRED` | Wallet is on a different plan | Use `helius upgrade` | | `EXPIRED` / `FAILED` | Intent can no longer be paid | Run `helius signup` again | | `MISSING_PENDING_INTENT` | `--resume` with nothing stored | Run `helius signup` first | ## Error Handling With `--json`, errors are returned as an envelope with `ok: false` and a non-zero exit code: ```json { "ok": false, "v": 1, "error_code": "INSUFFICIENT_USDC", "category": "payment", "error": "Wallet YourWalletAddress... needs 10 USDC (have 0.00).", "recoverable": false, "suggestion": "..." } ``` A new signup without `--email`, `--first-name`, or `--last-name` fails with a "Signup requires contact info" error naming the missing fields. ### Exit Codes | Code | Meaning | Action | |------|---------|--------| | 0 | Success | Read `data.status` | | 1 | General error | Check message, retry with backoff | | 11 | Keypair not found | Run `helius keygen` first | | 12 | Auth failed | Check keypair validity | | 20 | Insufficient SOL | Fund wallet with ~0.001 SOL (autopay only) | | 21 | Insufficient USDC | Fund wallet with 10 USDC (autopay only) | | 22 | Payment failed | Retry or check network status | | 40 | API error | Retry with exponential backoff | | 53 | Invalid input | Fix the arguments (e.g. invalid email) | ## Command Reference | Command | Purpose | |---------|---------| | `helius keygen` | Generate new keypair at `~/.helius/keypair.json` | | `helius keygen -o ` | Generate keypair at custom path | | `helius signup --email --first-name --last-name --json` | Create payment intent, print hosted payment link | | `helius signup --plan agent --pay --email --first-name --last-name --json` | Autopay USDC from the local keypair and provision | | `helius signup --resume --json` | Finalize after paying via the link | | `helius signup --restart ...` | Discard a stored intent and start over | | `helius signup -k ...` | Use a custom keypair | | `helius plans --json` | List plans and prices | | `helius projects --json` | List projects | | `helius apikeys --json` | List API keys | | `helius usage --json` | Check credit usage | ## Agent Implementation Pseudocode ``` 1. CHECK if helius-cli installed - Run: `helius --version` - If fails: run `npm install -g helius-cli` 2. CHECK if keypair exists at ~/.helius/keypair.json - If not: run `helius keygen` 3. COLLECT a valid email, first name, and last name from the account owner - Required for every new signup; do not invent placeholder values 4. RUN `helius signup --email --first-name --last-name --json` - ALREADY_SUBSCRIBED: extract data.apiKey, done - UPGRADE_REQUIRED: use `helius upgrade` - PAYMENT_REQUIRED: continue 5. PAY - Hosted: give data.paymentUrl to the user to pay with any wallet - Autopay: fund the keypair with 10 USDC (data.amountCents / 100) + ~0.001 SOL, then re-run step 4 with `--pay` 6. RUN `helius signup --resume --json` until data.status is SUCCESS (PENDING: wait and retry; EXPIRED/FAILED: restart from step 4) 7. STORE data.apiKey, data.projectId, data.endpoints.mainnet, data.endpoints.devnet 8. VERIFY API key works: - POST to RPC endpoint with getHealth method - Expected: {"jsonrpc":"2.0","result":"ok","id":1} ``` ## Transaction Tracking All Solana transactions can be tracked at: ``` https://orbmarkets.io/tx/{transaction_signature} ``` ## Important Notes - **Contact info is mandatory:** new accounts require a valid email, first name, and last name. - **Network:** All payments are on Solana **mainnet** (not devnet). The API key works on both mainnet and devnet. - **Idempotent:** Re-running signup reuses a pending intent; a wallet already on the plan gets `ALREADY_SUBSCRIBED` with no new charge. - **Config Location:** `~/.helius/config.json` - **Default Keypair:** `~/.helius/keypair.json` (Solana CLI 64-byte JSON array) ## Testing Your API Key ```bash curl "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY" \ -X POST \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"getHealth"}' ``` Expected response: `{"jsonrpc":"2.0","result":"ok","id":1}` ## What is Helius? Helius is the leading RPC and API provider for the Solana blockchain. The API key obtained through this CLI provides access to: - **RPC Endpoints:** High-performance Solana RPC for mainnet and devnet - **Enhanced APIs:** NFT metadata, transaction history, webhooks - **DAS API:** Digital Asset Standard API for compressed NFTs Documentation: https://www.helius.dev/docs/agents/cli --- ## CLI Reference _Source: https://www.helius.dev/cli.md_ > Official command-line interface for the Helius, Solana's leading developer platform. Built for developers and LLM agents. `helius` covers account management, Solana data queries (balances, transactions, assets, accounts, blocks), Digital Asset Standard (DAS), ZK compression, webhooks, priority fees, transaction sending, staking, and WebSocket streaming. Install: `npm install -g helius-cli` Agents: set `NO_DNA=1` to suppress spinners and unblock non-interactive flows. All data commands support `--json` for machine-readable output. `--retry ` enables exponential-backoff retry on transient errors. ## Error handling Commands exit with distinct codes per error class. When `--json` is set, errors are output as `{ error, message, retryable, guidance? }` on stdout; the `retryable` field indicates whether the error is transient (429, 5xx, network) vs. permanent (400, 401, 404, invalid input). Exit code ranges: - `0` success, `1` general error - `10-19` authentication (not logged in, keypair missing) - `20-29` balance/payment (insufficient SOL/USDC) - `30-39` project state - `40-49` API errors - `50-59` SDK/data errors (50 no API key, 52 invalid address, 53 invalid input, 54 invalid API key, 55 not found, 56 rate limited, 57 server error, 58 network error) ## Commands - [Account management](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#account-management): `keygen`, `signup`, `login`, `upgrade`, `pay`, `projects`, `project`, `apikeys`, `usage`, `rpc`, `status`, `plans`, `config` - [Balances & tokens](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#balances--tokens): `balance`, `tokens`, `token-holders` - [Transactions](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#transactions): `tx parse`, `tx history`, `tx scan`, `tx fees` - [Digital assets (DAS)](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#digital-assets-das-api): `asset get`, `asset batch`, `asset owner`, `asset creator`, `asset authority`, `asset collection`, `asset search`, `asset proof`, `asset proof-batch`, `asset editions`, `asset signatures`, `asset token-accounts` - [Account & network](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#account--network): `account`, `network-status`, `block` - [Wallet API](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#wallet-api): `wallet identity`, `wallet identity-batch`, `wallet balances`, `wallet history`, `wallet transfers`, `wallet funded-by` - [Webhooks](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#webhooks): `webhook list`, `webhook get`, `webhook create`, `webhook update`, `webhook delete` - [Program accounts](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#program-accounts): `program accounts`, `program accounts-all`, `program token-accounts` - [Staking](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#staking): `stake create`, `stake unstake`, `stake withdraw`, `stake accounts`, `stake withdrawable`, `stake instructions` - [ZK compression](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#zk-compression): `zk account`, `zk balance`, `zk token-holders`, `zk proof`, `zk validity-proof`, `zk tx`, `zk indexer-health`, and more - [Transaction sending](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#transaction-sending): `send broadcast`, `send raw`, `send sender`, `send poll`, `send compute-units` - [WebSocket streaming](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#websocket-streaming): `ws account`, `ws logs`, `ws slot`, `ws signature`, `ws program` - [SIMDs](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md#simds): `simd list`, `simd get` ## Global options - `--api-key ` — override the configured API key - `--network ` — `mainnet` (default) or `devnet` - `--json` — machine-readable JSON output - `--retry ` — retry transient errors up to `n` times with exponential backoff (default `0`) - `-k, --keypair ` — keypair file path (for `signup`, `login`, `upgrade`, `pay`, `stake`) ## Resources - [Full README](https://github.com/helius-labs/core-ai/blob/main/helius-cli/README.md): Complete command reference, configuration, and development setup for the Helius CLI - [Helius Agents Documentation](https://www.helius.dev/docs/agents/llms.txt): Machine-readable index of all agent-focused documentation for the Helius Solana platform - [Helius for Agents](https://www.helius.dev/docs/agents/overview.md): Everything AI agents need to build on Solana with Helius - [Helius Docs](https://www.helius.dev/docs): Platform API documentation (RPC, DAS, Sender, webhooks, Laserstream) - [Helius Dashboard](https://dashboard.helius.dev): Manage API keys, billing, and webhooks in the browser --- ## API Catalog _Source: https://www.helius.dev/api/llms.txt_ > Solana RPC, DAS, Sender, Wallet, Webhooks, Priority Fee, ZK Compression, and Admin — every Helius API surface with its OpenAPI spec and docs URL. This is a narrower agent-readable index than the site-wide https://www.helius.dev/llms.txt. For the merged OpenAPI catalog as a single JSON document, see https://www.helius.dev/openapi.json. For the RFC 9727 discovery linkset, see https://www.helius.dev/.well-known/api-catalog. ## Authentication All Helius public API endpoints accept the API key as the `api-key` query parameter (e.g. `https://mainnet.helius-rpc.com/?api-key=YOUR_KEY`). Obtain a key at https://dashboard.helius.dev or programmatically via `helius signup --email --first-name --last-name --json` (CLI; valid email required; $10 USDC one-time on Solana mainnet). ## Networks Mainnet (`mainnet.helius-rpc.com`) and devnet (`devnet.helius-rpc.com`) are supported across RPC, WebSocket, and LaserStream. Sender adds 7 regional endpoints (`slc-`, `ewr-`, `lon-`, `fra-`, `ams-`, `sg-`, `tyo-` prefixes on `sender.helius-rpc.com`). ## API Surfaces ### Solana RPC (HTTP) + Helius extensions High-performance Solana RPC plus Helius extensions like getTransactionsForAddress and getTransfersForAddress for single-call address history. - Endpoint: `https://mainnet.helius-rpc.com` - OpenAPI spec: https://www.helius.dev/openapi/rpc-http.json - Documentation: https://www.helius.dev/docs/rpc/guides/overview ### Digital Asset Standard (DAS) API Unified API for Solana NFTs, compressed NFTs, and tokens — metadata, ownership, Merkle proofs, and search. - Endpoint: `https://mainnet.helius-rpc.com` - OpenAPI spec: https://www.helius.dev/openapi/das-api.json - Documentation: https://www.helius.dev/docs/das-api ### Helius Sender Reliable transaction submission with atomic bundle support and high-speed routing. 7 regional endpoints for low-latency global coverage. - Endpoint: `https://sender.helius-rpc.com` - OpenAPI spec: https://www.helius.dev/openapi/sender-api.json - Documentation: https://www.helius.dev/docs/sending-transactions/sender ### Wallet API REST endpoints for wallet-level portfolio views: USD balances, holdings, transfer history, funding source, and identity resolution. - Endpoint: `https://api.helius.xyz/v1/wallet` - OpenAPI spec: https://www.helius.dev/openapi/wallet-api.json - Documentation: https://www.helius.dev/docs/wallet-api/overview ### Priority Fee API Recommended priority fee estimates for reliable transaction landing under network load. - Endpoint: `https://mainnet.helius-rpc.com` - OpenAPI spec: https://www.helius.dev/openapi/priority-fee-api.json - Documentation: https://www.helius.dev/docs/priority-fee-api ### ZK Compression Indexer Compressed-account queries: state, balances, proofs, validity proofs, and compression history. - Endpoint: `https://mainnet.helius-rpc.com` - OpenAPI spec: https://www.helius.dev/openapi/zk-compression.json - Documentation: https://www.helius.dev/docs/zk-compression/introduction ### Admin API Project usage and billing data for Helius accounts (admin-authenticated). - Endpoint: `https://admin-api.helius.xyz` - OpenAPI spec: https://www.helius.dev/openapi/admin-api.json - Documentation: https://www.helius.dev/docs/api-reference/admin ### Helius Webhooks Create, update, list, and delete webhooks that push transaction and account events to an HTTPS endpoint. - Endpoint: `https://api.helius.xyz/v0/webhooks` - OpenAPI spec: https://www.helius.dev/openapi/webhooks.json - Documentation: https://www.helius.dev/docs/webhooks ## SDKs - **TypeScript** — [helius-sdk on npm](https://www.npmjs.com/package/helius-sdk) (`npm install helius-sdk`). Source: https://github.com/helius-labs/helius-sdk - **Rust** — [helius on crates.io](https://crates.io/crates/helius) (`cargo add helius`). Source: https://github.com/helius-labs/helius-rust-sdk. Docs: https://docs.rs/helius ## Rate Limits Vary by plan. Full per-feature table: https://www.helius.dev/pricing.md. - Free: 10 RPS, 1 sendTransaction/sec, 1M credits/month - Developer: 50 RPS, 5 sendTx/sec, 10M credits - Business: 200 RPS, 50 sendTx/sec, 5 sendBundle/sec, 100M credits - Professional: 500 RPS, 100 sendTx/sec, 5 sendBundle/sec, 200M credits --- ## Parsed Data Program Catalog _Source: https://www.helius.dev/parsed-data/llms.txt_ > Decoded instruction, event, argument, and account-role references for published Solana programs. Snapshot: 2026-10-08. - [Browse all companies](https://www.helius.dev/parsed-data/programs.md) ## Companies and programs - [Pump.fun](https://www.helius.dev/parsed-data/pump-fun.md): Leading token launchpad, AMM, and mobile trading app - [Pump.fun Fees Program](https://www.helius.dev/parsed-data/pump-fun/fees.md) — `pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ` - [Pump.fun AMM](https://www.helius.dev/parsed-data/pump-fun/amm.md) — `pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA` - [Pump.fun Program](https://www.helius.dev/parsed-data/pump-fun/program.md) — `6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P` - [Meteora](https://www.helius.dev/parsed-data/meteora.md): Automated market maker (AMM) and liquidity infra - [Meteora DLMM Program](https://www.helius.dev/parsed-data/meteora/dlmm.md) — `LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo` - [Meteora DAMM V2 Program](https://www.helius.dev/parsed-data/meteora/damm-v2.md) — `cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG` - [Meteora Dynamic Bonding Curve Program](https://www.helius.dev/parsed-data/meteora/dynamic-bonding-curve.md) — `dbcij3LWUppWqq96dh6gJWwBifmcGfLSB5D4DuSMaqN` - [Meteora DAMM v1 Program](https://www.helius.dev/parsed-data/meteora/damm-v1.md) — `Eo7WjKq67rjJQSZxS6z3YkapzY3eMj6Xy8X5EQVn5UaB` - [Meteora Zap Program](https://www.helius.dev/parsed-data/meteora/zap.md) — `zapvX9M3uf5pvy4wRPAbQgdQsM1xmuiFnkfHKPvwMiz` - [Jupiter](https://www.helius.dev/parsed-data/jupiter.md): DEX, perpetual futures, lending, and DeFi super app - [Jupiter Aggregator V6](https://www.helius.dev/parsed-data/jupiter/aggregator-v6.md) — `JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4` - [Jupiter Lend AMM Program](https://www.helius.dev/parsed-data/jupiter/lend-amm.md) — `jupZ4m2GqUCJ5iueMfzQf8khFfH31d4XAQt3RzCT9Vd` - [Jupiter Perps Program](https://www.helius.dev/parsed-data/jupiter/perps.md) — `PERPHjGBqRHArX4DySjwM6UJHiR3sWAatqfdBS2qQJu` - [Jupiter Prediction Market Program](https://www.helius.dev/parsed-data/jupiter/prediction-market.md) — `3ZZuTbwC6aJbvteyVxXUS7gtFYdf7AuXeitx6VyvjvUp` - [Jupiter Limit Order V1](https://www.helius.dev/parsed-data/jupiter/limit-order-v1.md) — `j1o2qRpjcyUwEvwtcfhEQefh773ZgjxcVRry7LDqg5X` - [Jupiter Offerbook Program](https://www.helius.dev/parsed-data/jupiter/offerbook.md) — `offerbkFMvVfpQhL8ZQ5iromnjct5rz3r52B9ewu3ie` - [Orca](https://www.helius.dev/parsed-data/orca.md): Decentralized exchange (DEX) and liquidity protocol - [Orca Whirlpool Program](https://www.helius.dev/parsed-data/orca/whirlpool.md) — `whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc` - [xORCA Staking Program](https://www.helius.dev/parsed-data/orca/xorca-staking.md) — `StaKE6XNKVVhG8Qu9hDJBqCW3eRe7MDGLz17nJZetLT` - [Raydium](https://www.helius.dev/parsed-data/raydium.md): Automated market maker (AMM), launchpad, and liquidity - [Raydium Concentrated Liquidity Program](https://www.helius.dev/parsed-data/raydium/concentrated-liquidity.md) — `CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK` - [Raydium CP Swap](https://www.helius.dev/parsed-data/raydium/cp-swap.md) — `CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C` - [Raydium LaunchLab Program](https://www.helius.dev/parsed-data/raydium/launchlab.md) — `LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj` - [DFlow](https://www.helius.dev/parsed-data/dflow.md): Decentralized trading and routing infrastructure - [DFlow Program v4](https://www.helius.dev/parsed-data/dflow/program-v4.md) — `DF1ow4tspfHX9JwWJsAb9epbkA8hmpSEAtxXy1V27QBH` - [OKX](https://www.helius.dev/parsed-data/okx.md): Solana DEX router and centralized crypto exchange - [OKX DEX Router Program](https://www.helius.dev/parsed-data/okx/dex-router.md) — `proVF4pMXVaYqmy4NjniPh4pqKNfMmsihgd4wdkCX3u` - [Byreal](https://www.helius.dev/parsed-data/byreal.md): Decentralized exchange and onchain liquidity programs - [Byreal CLMM Program](https://www.helius.dev/parsed-data/byreal/clmm.md) — `REALQqNEomY6cQGZJUGwywTBD2UmDT32rZcNnfxQ5N2` - [Byreal Router Program](https://www.helius.dev/parsed-data/byreal/router.md) — `REALp6iMBDTctQqpmhBo4PumwJGcybbnDpxtax3ara3` - [Phantom](https://www.helius.dev/parsed-data/phantom.md): Crypto wallet with native trading and RFQs - [Phantom Transfer Program](https://www.helius.dev/parsed-data/phantom/transfer.md) — `Send9wszHjEiS3hwKcPeSLsPRu5Gb62iCrJEcG4Mq3b` - [Phantom RFQ Program](https://www.helius.dev/parsed-data/phantom/rfq.md) — `2En5Y11SEAGLNmEezTuRUCwTyzyNReHaMbSnS5gjGsL1` - [Wormhole](https://www.helius.dev/parsed-data/wormhole.md): Cross-chain messaging and interoperability protocol - [Wormhole Receiver](https://www.helius.dev/parsed-data/wormhole/wormhole-receiver.md) — `HDwcJBJXjL9FpJ7UBsYBtaDjsBUhuLCUYoz3zr8SWWaQ` - [Pyth](https://www.helius.dev/parsed-data/pyth.md): Onchain oracle publishing 1st party financial market data - [Pyth Lazer Solana Program](https://www.helius.dev/parsed-data/pyth/lazer-solana.md) — `pytd2yyk641x7ak7mkaasSJVXh6YYZnC7wTmtgAyxPt` - [Pyth Push Oracle Program](https://www.helius.dev/parsed-data/pyth/push-oracle.md) — `pyt2F414BA6dPttK6RddPZUdHfapoBN24GL5wbrPCou` - [Pyth Solana Receiver Program](https://www.helius.dev/parsed-data/pyth/solana-receiver.md) — `rec2HHDDnjLfj4kE7VyEtFA1HPGQLK33259532cRyHp` - [Pyth Staking Program](https://www.helius.dev/parsed-data/pyth/staking.md) — `pytS9TjG1qyAZypk7n8rw8gfW9sUaqqYyMhJQ4E7JCQ` - [Kamino](https://www.helius.dev/parsed-data/kamino.md): Leading borrow/lending and vault protocol on Solana - [Kamino Lending Vault Program](https://www.helius.dev/parsed-data/kamino/lending-vault.md) — `KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd` - [Kliquidity Program](https://www.helius.dev/parsed-data/kamino/kliquidity.md) — `6LtLpnUFNByNXLyCoK9wA2MykKAmQNZKBdY8s47dehDc` - [Phoenix](https://www.helius.dev/parsed-data/phoenix.md): Fully onchain spot and perpetual futures exchange - [Phoenix Flight Program](https://www.helius.dev/parsed-data/phoenix/flight.md) — `F1ightu9cujFYo34k9CabifLrJT8qzfDVM2Q7BqhJn2W` - [Beta Phoenix Perpetuals Program](https://www.helius.dev/parsed-data/phoenix/beta-phoenix-perpetuals.md) — `phDEVv4w6BcfkLrLNeXr8HhhgQxnxziVGXpGPcaadMf` - [LayerZero](https://www.helius.dev/parsed-data/layerzero.md): Interoperability protocol for cross-chain messaging - [LayerZero Endpoint Program](https://www.helius.dev/parsed-data/layerzero/endpoint.md) — `76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6` - [LayerZero Executor Program](https://www.helius.dev/parsed-data/layerzero/executor.md) — `6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn` - [LayerZero DVN Program](https://www.helius.dev/parsed-data/layerzero/dvn.md) — `HtEYV4xB4wvsj5fgTkcfuChYpvGYzgzwvNhgDZQNh7wW` - [Chainlink](https://www.helius.dev/parsed-data/chainlink.md): Oracle infrastructure for data feeds and data streams - [Chainlink Store Program](https://www.helius.dev/parsed-data/chainlink/store.md) — `HEvSKofvBgfaexv23kMabbYqxasxU3mQ4ibBMEmJWHny` - [Chainlink Data Streams Verifier Program](https://www.helius.dev/parsed-data/chainlink/data-streams-verifier.md) — `Gt9S41PtjR58CbG9JhJ3J6vxesqrNAswbWYbLNTMZA3c` - [Chainlink OCR2 Oracle Program](https://www.helius.dev/parsed-data/chainlink/ocr2-oracle.md) — `cjg3oHmg9uuPsP8D6g29NWvhySJkdYdAo9D25PRbKXJ` --- ## Documentation Index _Source: https://www.helius.dev/docs/llms.txt_ --- url: https://www.helius.dev/docs last_updated: 2026-11-18 --- # Helius Documentation The leading Solana RPC and infrastructure platform. Fast, reliable APIs for building on Solana. ## Getting Started 1. Sign up at https://dashboard.helius.dev 2. Get your API key 3. Start building with any of our APIs below ## Getting Started (Agents) Programmatically create a Helius account and generate an API key. Guide: https://www.helius.dev/docs/agents/cli.md Full instructions: https://dashboard.helius.dev/agents.md ### Step 1: Install CLI Programmatically create accounts and get API keys via CLI: ```bash npm install -g helius-cli ``` ### Step 2: Generate Keypair ```bash helius keygen ``` Output: Creates keypair at `~/.helius/keypair.json` Returns: Wallet address to fund ### Step 3: Fund Wallet (Autopay only) Skip this step if paying via the hosted payment link (the default signup mode, finalized with `helius signup --resume`). Autopay (`--pay`) pays USDC from the local keypair, which must be funded first. For autopay, send to the wallet address from Step 2: - Plan USDC (token: `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`) - ~0.001 SOL ### Step 4: Signup and Get API Key Two payment modes: ```bash # Default: prints a hosted payment link — pay with any wallet in the browser helius signup --email you@example.com --first-name Jane --last-name Doe --json # After paying via the link, finalize the account helius signup --resume --json # Or autopay from the funded local keypair (Step 3); Agent is the default plan helius signup --plan agent --pay --email you@example.com --first-name Jane --last-name Doe --json ``` Note: the default `helius signup` returns a hosted payment URL, not an API key. The success fields below come from `helius signup --resume` or autopay (`--pay`). #### Success Response from `--resume` or `--pay` (exit code 0): ```json { "status": "SUCCESS", "apiKey": "your-api-key-here", "endpoints": { "mainnet": "https://mainnet.helius-rpc.com/?api-key=your-api-key-here", "devnet": "https://devnet.helius-rpc.com/?api-key=your-api-key-here" }, "credits": 1000000 } ``` Extract API key: `response.apiKey` Extract RPC URL: `response.endpoints.mainnet` or `response.endpoints.devnet` ## Quick Reference - Mainnet RPC: https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY - Mainnet RPC (Gatekeeper Beta): https://beta.helius-rpc.com/?api-key=YOUR_API_KEY - Devnet RPC: https://devnet.helius-rpc.com/?api-key=YOUR_API_KEY - Mainnet WSS: wss://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY (LaserStream WebSocket: standard Solana subscriptions plus Helius extensions) - Mainnet WSS (Gatekeeper Beta): wss://beta.helius-rpc.com/?api-key=YOUR_API_KEY (LaserStream WebSocket: standard Solana subscriptions plus Helius extensions; also Parsed Streams, Preconfirmations, and preprocessedSubscribe) - Devnet WSS: wss://devnet.helius-rpc.com/?api-key=YOUR_API_KEY (LaserStream WebSocket: standard Solana subscriptions plus Helius extensions) - Auth: API key via query parameter (?api-key=YOUR_API_KEY) - Billing: https://www.helius.dev/docs/billing/llms.txt - Dashboard: https://dashboard.helius.dev - Status: https://helius.statuspage.io ## API Documentation ### Solana RPC Standard Solana JSON-RPC methods with enhanced performance. https://www.helius.dev/docs/api-reference/rpc/http/llms.txt ### LaserStream WebSocket Helius's WebSocket streaming product. Serves the standard Solana WebSocket subscriptions plus Helius extensions (`transactionSubscribe`, enhanced `accountSubscribe`) for advanced filtering on a single unified endpoint, on the same backend as LaserStream gRPC. Standard methods are available on all plans; Helius extensions require a Developer, Business, or Professional plan. https://www.helius.dev/docs/api-reference/rpc/websocket/llms.txt ### Solana DAS API Unified interface for all Solana digital assets: NFTs, compressed NFTs, fungible tokens. - Overview: https://www.helius.dev/docs/das-api.md - API index: https://www.helius.dev/docs/api-reference/das/llms.txt ### Solana Enhanced Transactions API (legacy, maintenance mode) Parsed, human-readable transaction data with automatic labeling. Legacy product in maintenance mode — its successor is Parsed Events (below); use Parsed Events for new builds. - Parsed Events overview: https://www.helius.dev/docs/parsed-events.md - Parsed Events quickstart: https://www.helius.dev/docs/parsed-events/quickstart.md - Migration guide: https://www.helius.dev/docs/parsed-events/guides/migrate-from-enhanced-transactions.md ### Helius Parsed Events Parse transaction signatures or address history into decoded instructions, transfers, and summaries over REST. Successor to Enhanced Transactions, built on the same IDL catalog (3,600+ programs) as Parsed Streams. Generally available on all plans (including Free) at 10 credits per request; authenticate with your API key. Base URL: `https://mainnet.helius-rpc.com`. REST methods: `POST /v1/parsed-events/transactions`, `POST /v1/parsed-events/transaction-history`, `POST /v1/parsed-events/scan` (server-side search of an address's history by program instruction or token mint), `GET /v1/parsed-events/idl/{programId}` (list a program's IDL versions), `GET /v1/parsed-events/idl/{programId}/{slot}` (the IDL in effect at a slot). - Overview: https://www.helius.dev/docs/parsed-events.md - Quickstart and REST reference: https://www.helius.dev/docs/parsed-events/quickstart.md - API reference: https://www.helius.dev/docs/api-reference/parsed-events/overview.md - Scan transaction history: https://www.helius.dev/docs/api-reference/parsed-events/scan.md - List IDL versions: https://www.helius.dev/docs/api-reference/parsed-events/idl-versions.md - Get IDL: https://www.helius.dev/docs/api-reference/parsed-events/idl.md - Response field reference: https://www.helius.dev/docs/parsed-events/parsed-response.md - Migrate from Enhanced Transactions: https://www.helius.dev/docs/parsed-events/guides/migrate-from-enhanced-transactions.md ### Helius LaserStream gRPC gRPC streaming (`Subscribe` / SDK `subscribe` from `helius-laserstream`) for Solana transaction, account, block, and slot updates with request filters, up to 48-hour historical replay, automatic multi-node failover, and commitment-aware delivery. MCP `heliusStreaming` action `laserstreamSubscribe` generates and validates subscription config and a TypeScript example; it does not open or maintain a live stream. For browser/UI WSS use LaserStream WebSocket; for HTTP callbacks use Webhooks; Preconfirmations and Shred Delivery are separate earlier-lifecycle products. - Overview: https://www.helius.dev/docs/laserstream.md - API reference overview: https://www.helius.dev/docs/api-reference/laserstream-grpc.md - Subscribe: https://www.helius.dev/docs/api-reference/laserstream/grpc/subscribe.md - Replay availability (SubscribeReplayInfo): https://www.helius.dev/docs/api-reference/laserstream/grpc/subscribereplayinfo.md - Clients: https://www.helius.dev/docs/laserstream/clients.md - API index: https://www.helius.dev/docs/api-reference/laserstream/grpc/llms.txt ### Helius Parsed Streams WebSocket service that streams decoded Solana transactions with server-side filtering by program, account, and instruction name. Instructions arrive decoded through Helius's IDL catalog (3,600+ programs): named arguments, named accounts, inner (CPI) instructions included. Successor to Enhanced Transaction Webhooks. Generally available on all plans (including Free) at 1 credit per delivered event, the same rate as webhooks; authenticate with your API key. Endpoint: `wss://beta.helius-rpc.com/?api-key=` (the Gatekeeper host). Exception: describeProgram is currently only available on `wss://fs-beta.helius-rpc.com/?api-key=`. - Overview: https://www.helius.dev/docs/parsed-streams.md - Quickstart and protocol reference: https://www.helius.dev/docs/parsed-streams/quickstart.md - describeProgram (program discovery): https://www.helius.dev/docs/api-reference/parsed-streams/describeprogram.md ### Helius Sender Lowest latency transaction sending service. Accepts the same `sendTransaction` request as standard RPC. No credits consumed; a SOL tip is required per transaction. Two tiers: Sender Max submits across all pathways (Helius, Jito, Harmonic, Rakurai, etc.) simultaneously and supports transactions and bundles (minimum tip 0.001 SOL); Sender SWQOS-only routes through a single cost-optimized SWQOS path (minimum tip 0.000005 SOL). - Overview and quickstart: https://www.helius.dev/docs/sending-transactions/sender.md - Choosing how to send: https://www.helius.dev/docs/sending-transactions/overview.md - Sender Max: https://www.helius.dev/docs/sending-transactions/sender-max.md - Sender SWQOS-Only: https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md - API reference: https://www.helius.dev/docs/api-reference/sender/llms.txt ### MEV Protect Opt-in routing (`mev-protect=true` query parameter) that avoids validators statistically linked to sandwich attacks. Works with basic sendTransaction, basic sendBundle, Sender Max, and Sender SWQOS-only. https://www.helius.dev/docs/sending-transactions/mev-protect.md ### Helius Preconfirmations Stream Solana transactions at the lowest possible latency — before they are collected into entries and shredded. The stream merges two sources that emit at different points: Helius preconfirmations are emitted the instant the leader executes a transaction and carry its execution status, while Jito BAM (Block Assembly Marketplace) preconfirmations are emitted when the validator commits to executing a transaction, before it runs. Subscribe via `preconfSubscribe` WebSocket on the Gatekeeper endpoint (`wss://beta.helius-rpc.com`); use `includeSource: ["helius"]` or `includeSource: ["bam"]` to select one source. BAM messages always carry `tx_index = 0` and `status = 2` (unknown), the payload has no source field, and the same signature can arrive from both sources. Transaction bytes are in Solana wire format (legacy, v0, or v1); decode with a v1-aware parser such as `agave-transaction-view` (Rust), not `bincode`. Available on all paid plans (Developer, Business, Professional, and Enterprise); Free is excluded. Slots with zero delivered messages cost zero credits, even when the slot has preconfirmation coverage. When a slot delivers at least one message, each open `preconfSubscribe` subscription is billed the greater of 300 credits or 10 credits per delivered message. Uncovered slots cost zero. Therefore, 0, 10, 30, and 100 delivered messages bill 0, 300, 300, and 1,000 credits respectively. - Overview: https://www.helius.dev/docs/pre-confirmations/overview.md - preconfSubscribe guide: https://www.helius.dev/docs/pre-confirmations/preconf-subscribe.md - preconfSubscribe API reference: https://www.helius.dev/docs/api-reference/pre-confirmations/preconfsubscribe.md - preconfUnsubscribe API reference: https://www.helius.dev/docs/api-reference/pre-confirmations/preconfunsubscribe.md - getPreConfCoverage API reference (combined Helius and BAM stake coverage): https://www.helius.dev/docs/api-reference/pre-confirmations/getpreconfcoverage.md ### Helius Shred Delivery Self-serve raw Solana shreds via UDP. $1,000 USD/month per IP ($800 USD/month per IP on Pro plans). https://www.helius.dev/docs/shred-delivery/llms.txt ### Helius Preprocessed Transactions Pre-execution Solana transactions delivered before `processed` commitment — aggregated primarily from shred decoding, supplemented by preconfirmation signals (the dedicated Preconfirmations product remains the earliest access to those). Streamed via the `preprocessedSubscribe` WebSocket on `wss://beta.helius-rpc.com` (public beta, all paid plans, 0.1 credits per message). - Overview: https://www.helius.dev/docs/preprocessed-transactions/overview.md - preprocessedSubscribe guide: https://www.helius.dev/docs/preprocessed-transactions/preprocessed-subscribe.md ### Helius Priority Fee API Optimal priority fee estimation for transaction landing. - Overview: https://www.helius.dev/docs/priority-fee-api.md - API index: https://www.helius.dev/docs/api-reference/priority-fee/llms.txt ### Solana Webhooks Real-time HTTP POST notifications for blockchain events. https://www.helius.dev/docs/api-reference/webhooks/llms.txt ### Helius Wallet API Query Solana wallet balances, transaction history, transfers, identities, and funding sources with structured REST endpoints. https://www.helius.dev/docs/api-reference/wallet-api/llms.txt ### ZK Compression API Compressed account and token operations. https://www.helius.dev/docs/api-reference/zk-compression/llms.txt ### Helius Wallet-as-a-Service (WaaS) — beta Non-custodial embedded Solana wallets for your app via the `helius-wallet-kit` npm package (React). Users sign in with a passkey or email one-time code by default (SMS and external-wallet sign-in can be enabled; social logins coming soon) — no seed phrases; keys are secured by Turnkey and signing happens client-side. Paid plans only. Billed 200 credits per signature (`signMessage`, `signTransaction`, `signAndSendTransaction`); no per-wallet or per-MAU fee. Not the Wallet API (that is a read-only REST data API). - Section index: https://www.helius.dev/docs/waas/llms.txt - Overview: https://www.helius.dev/docs/waas/overview.md - Quickstart: https://www.helius.dev/docs/waas/quickstart.md - Migrating from Privy: https://www.helius.dev/docs/waas/migrating-from-privy.md ### Solana Privacy Rings Programmable privacy for Solana transfers, secured by zero-knowledge proofs and settled natively on Solana (no sequencer or sidechain). Confidential transfers keep the asset and amount private while sender and recipient stay public; anonymous Custom Rings hide all four (asset, amount, sender, and recipient). Self-custodial: in the permissionless Default Ring, spending always requires the owner's signature (Custom Ring policy can add co-signers, freeze/thaw authorities, or a permanent delegate). The permissionless Solana Privacy Ring is live on Solana mainnet. Custom Rings are currently being audited, with a target mainnet release in Q4 2026. SDKs: `@heliuslabs/zolana` (TypeScript), `zolana-client` (Rust). - Reads: 10 credits per request. Proof generation: 1,000 credits per proof. - Plan availability: Free, Developer, Business, and Professional. - Read requests per second (Free / Developer / Business / Professional): 2 / 10 / 50 / 100. - Proof generation requests per second (Free / Developer / Business / Professional): 1 / 5 / 10 / 20. - Credits: https://www.helius.dev/docs/billing/credits.md#solana-privacy-rings-api-credits - Rate limits: https://www.helius.dev/docs/billing/rate-limits.md#solana-privacy-rings-api - Section index: https://www.helius.dev/docs/privacy/llms.txt - Overview: https://www.helius.dev/docs/privacy.md - Concepts Overview: https://www.helius.dev/docs/privacy/concepts/overview.md - Architecture (wallets, RPC services, programs, and proving): https://www.helius.dev/docs/privacy/concepts/architecture.md - Private State and UTXOs (balances, spending, and concurrency): https://www.helius.dev/docs/privacy/concepts/utxo.md - Shielded Keypair and Encryption (keys and decryption modes): https://www.helius.dev/docs/privacy/concepts/encryption.md - Deposit guide: https://www.helius.dev/docs/privacy/guides/deposit.md - Transfer guide: https://www.helius.dev/docs/privacy/guides/transfer.md - Withdraw guide: https://www.helius.dev/docs/privacy/guides/withdraw.md - Read a private balance: https://www.helius.dev/docs/privacy/guides/read-balance.md - Read private history: https://www.helius.dev/docs/privacy/guides/read-history.md - Endpoints: https://www.helius.dev/docs/privacy/endpoints.md - SDK: https://www.helius.dev/docs/privacy/sdk.md - Privacy API reference (encrypted UTXOs, shielded history, proofs, and registry): https://www.helius.dev/docs/api-reference/privacy/llms.txt ### Gatekeeper (beta) Helius's edge gateway that removes Cloudflare from the critical path — response-time improvements range from tens to hundreds of milliseconds. Drop-in URL swap to `beta.helius-rpc.com`: same API key, same methods, identical responses, same pricing. Mainnet only for now. Serves all standard Solana RPC methods, Helius RPC extensions (e.g. getTransactionsForAddress), LaserStream WebSocket subscriptions, DAS API, ZK Compression (Photon), Priority Fee API, and Enhanced Transactions API — but not LaserStream gRPC. Note: the `beta.` hostname refers to the Gatekeeper rollout, not to the maturity of the products it serves. Parsed Streams, Preconfirmations, and the recommended `preprocessedSubscribe` WebSocket are served exclusively from `beta.helius-rpc.com` (a deprecated Preprocessed gRPC feed remains on the LaserStream endpoints). - Section index: https://www.helius.dev/docs/gatekeeper/llms.txt - Overview: https://www.helius.dev/docs/gatekeeper/overview.md - Migration guide: https://www.helius.dev/docs/gatekeeper/migration-guide.md ### Helius Admin API Programmatic access to project usage and billing data via API key authentication: credit usage, subscription details, and per-service request counts for the current credit cycle. - Overview: https://www.helius.dev/docs/api-reference/admin.md - Get project usage: https://www.helius.dev/docs/api-reference/admin/get-project-usage.md ## Common Use Cases | I'm building... | Use these Helius products | |-----------------|---------------------------| | Trading bot | Helius Sender (fast tx submission) + Priority Fee API + LaserStream (real-time prices) | | Wallet app | DAS API (getAssetsByOwner) + getTransactionsForAddress (paginated history; set `filters.tokenAccounts`, e.g. `"balanceChanged"`, for token-account activity — post-Dec-2022 only) or Wallet API for REST endpoints | | App with built-in wallets (no seed phrases) | WaaS embedded wallets (`helius-wallet-kit`) + Helius Sender (transaction landing) | | Private payments | Solana Privacy Rings | | NFT marketplace | DAS API (searchAssets, getAssetsByGroup) + Webhooks (track sales/listings) | | Token launcher | Helius Sender + Priority Fee API + Webhooks (monitor new token) | | Analytics dashboard | Parsed Events + getTransactionsForAddress (historical data) | | DeFi protocol | LaserStream (real-time account updates) + Helius Sender + Priority Fee API | | Sniper/MEV bot | Preconfirmations (earliest transaction signal) + Shred Delivery (raw shreds) + LaserStream gRPC (processed confirmation) + Helius Sender (staked connections) | | Portfolio tracker | DAS API (getAssetsByOwner with showFungible) + Parsed Events | | Airdrop tool | AirShip (95% cheaper with ZK compression) | | Jupiter/swap integration | Helius RPC + Helius Sender for transaction submission | ## Which API should I use? | Need | Use | |------|-----| | Get wallet NFTs and tokens | DAS API | | Parse transaction history | Parsed Events (Enhanced Transactions is legacy/maintenance mode) | | Real-time parsed events (decoded transactions over WebSocket) | Parsed Streams | | Real-time event notifications (HTTP) | Webhooks | | Real-time streaming (WebSocket) | LaserStream WebSocket | | Earliest transaction signal (before shreds) | Preconfirmations (`preconfSubscribe` WebSocket) | | Ultra low-latency Solana shreds (unprocessed) | Shred Delivery (raw shreds via dashboard) | | Lowest latency processed streaming | LaserStream gRPC | | Standard Solana RPC calls | RPC | | Estimate priority fees | Priority Fee API | | Work with compressed accounts | ZK Compression | | Simple REST endpoints for querying Solana wallet data | Wallet API | | Embedded non-custodial wallets in your app | WaaS (`helius-wallet-kit`) | | Confidential or private transfers | Solana Privacy Rings | | Lower latency on existing RPC/API calls | Gatekeeper endpoints (`beta.helius-rpc.com`) | | Visually explore transactions, tokens, wallets | Orb Explorer (https://orbmarkets.io) | ## Don't Confuse These | If you want to... | Use this | NOT this | Why | |-------------------|----------|----------|-----| | Get wallet's NFTs and tokens | `getAssetsByOwner` (DAS API; method-specific `showFungible` for SPL/Token-2022) | `getTokenAccountsByOwner` | `getTokenAccountsByOwner` returns raw accounts, not token metadata; use paginated DAS for NFT inventory — Wallet API Balances is not a complete NFT inventory | | Get filtered history or backfill (incl. token-account activity) | `getTransactionsForAddress` | `getSignaturesForAddress` | Use `transactionDetails: "full"` only when raw tx + metadata are needed; `filters.tokenAccounts` defaults to `none` (`balanceChanged` for balance-changing ATA activity) | | Get wallet-centric activity with per-transaction balance changes | Wallet API History (beta) | `getTransactionsForAddress` | Wallet-oriented REST response with balance changes — not GTFA filtered backfill or raw full transaction objects | | Get transfer-only history for a wallet | `getTransfersByAddress` | `getTransactionsForAddress` | Transfer-level SOL/token records, not full transaction objects | | Read an account or a wallet's token accounts as they were at a past slot | `getHistoricalAccountInfo` / `getHistoricalTokenAccountsByOwner` | `getAccountInfo` / `getTokenAccountsByOwner` | Standard methods only return current state; historical methods (beta) cover slot 444959999 (epoch 1030) onward | | Get parsed human-readable history (new builds) | Parsed Events | Enhanced Transactions (legacy) | Enhanced is in maintenance mode; GTFA is not a drop-in Enhanced response format | | Get transaction history for cNFTs | `getSignaturesForAsset` (DAS API) | `getSignaturesForAddress` | `getSignaturesForAddress` doesn't work for compressed NFTs | | Stream real-time data (choose by delivery model) | LaserStream WebSocket (WSS/browser), LaserStream gRPC (backend + replay), or Webhooks (HTTP callbacks) | Polling or Yellowstone gRPC on dedicated nodes for greenfield work | Match the delivery model; do not default every new project to gRPC | | Stream over gRPC with replay / multi-node failover | LaserStream gRPC `Subscribe` (SDK `subscribe`) | LaserStream WebSocket `transactionSubscribe` | WebSocket is for persistent WSS/browser/UI; MCP `laserstreamSubscribe` only generates config/examples | | Submit a signed transaction with the lowest latency | Helius Sender (multi-path routing across all pathways: Helius, Jito, Harmonic, Rakurai, etc.) | Standard `sendTransaction` | Standard `sendTransaction` submits through a single path | | Get priority fee estimates | `getPriorityFeeEstimate` | `getRecentPrioritizationFees` | `getRecentPrioritizationFees` requires manual calculation | | Search NFTs by collection | DAS API `getAssetsByGroup` or `searchAssets` | `getProgramAccounts` | `getProgramAccounts` is expensive, slow, and data could be unindexed | | Get real-time data | LaserStream WebSocket or LaserStream gRPC | Polling for real-time data | Polling is inefficient, higher latency, uses credits | | Get the earliest transaction signal | Preconfirmations (`preconfSubscribe`) | LaserStream gRPC at `processed` | Preconfirmations deliver transactions before shreds — Helius at leader execution (with status), BAM at commit-to-execute; LaserStream delivers data with commitment guarantees | | Get ultra low-latency, unprocessed transaction data | Shred Delivery (raw shreds) | LaserStream gRPC at `processed` | Shreds arrive before execution; LaserStream delivers post-execution data with commitment guarantees | | Add embedded wallets users control | WaaS (`helius-wallet-kit` SDK) | Wallet API | WaaS creates and signs with non-custodial embedded wallets; the Wallet API is a read-only REST data API for querying any wallet | | Cut RPC/WebSocket latency | Gatekeeper endpoint swap (`beta.helius-rpc.com`) | A new API integration | Gatekeeper serves identical methods and responses with the same API key — only the URL changes | Wallet API Balances (beta portfolio summaries): tokens are limited to 100 per page; NFTs are excluded unless `showNfts=true` (at most 100 NFTs on the first page only); `pricePerToken` and `usdValue` may be null; prices are hourly estimates, not real-time market prices; `totalUsdValue` covers the current page, not the full paginated portfolio; each request costs 100 credits. Use paginated DAS for complete NFT inventory and metadata. ## Key Concepts | Term | Definition | |------|------------| | DAS (Digital Asset Standard) | Standardized API for querying NFTs, tokens, and compressed assets with a unified interface | | cNFT (Compressed NFT) | NFTs stored in merkle trees instead of individual accounts; 1000x cheaper to mint | | ZK Compression | Technology to reduce on-chain storage costs by 98% using zero-knowledge proofs | | Helius Sender | Ultra low latency transaction submission service; the Sender Max tier submits a transaction across all pathways (Helius, Jito, Harmonic, Rakurai, etc.) simultaneously | | LaserStream | Helius's managed gRPC streaming service with historical replay and auto-reconnection. Wire-compatible with the Yellowstone gRPC protocol | | Yellowstone gRPC | Open-source Solana Geyser plugin protocol for streaming. LaserStream is wire-compatible with it; raw Yellowstone is also available on Helius dedicated nodes | | Priority Fee | Additional fee (in microlamports) to prioritize transaction inclusion in blocks | | Staked Connections | Direct connections to validators through stake-weighted routing for faster and more reliable transaction landing | | Associated Token Account (ATA) | The standard token account address derived from a wallet + mint; holds tokens on behalf of wallet | | Preconfirmations | Transactions streamed before shreds — Helius at leader execution (with status), BAM at commit-to-execute — Helius's lowest-latency transaction signal | | Commitment Level | Transaction finality: `processed` (fastest, may revert); under Alpenglow, `confirmed` and `finalized` are equivalent and permanent. Use `finalized` for new code because `confirmed` will be removed in a later release | | Gatekeeper | Helius edge gateway (`beta.helius-rpc.com`) that bypasses Cloudflare for lower latency; same APIs, keys, and pricing | | WaaS (Wallet-as-a-Service) | Embedded non-custodial Solana wallets via `helius-wallet-kit`, secured by Turnkey; billed 200 credits per signature | | Solana Privacy Rings | Confidential transfers secured by ZK proofs, settled natively on Solana mainnet | ## Pre-Execution Latency Stack From earliest to latest transaction signal: 1. **Preconfirmations** — transactions before shreds (Helius at leader execution, BAM at commit-to-execute). WebSocket `preconfSubscribe`. All paid plans; 10 credits per delivered message. Zero-message slots cost zero; slots with one or more delivered messages have a 300-credit minimum per subscription. 2. **Raw shreds (UDP)** — unprocessed shred packets. $1,000/month per IP ($800/month on Pro plans). 3. **`preprocessedSubscribe` (WebSocket)** — decoded pre-execution transactions (~8 ms ahead of `processed`) over WebSocket with account filtering, served from `wss://beta.helius-rpc.com`. All paid plans; public beta; 0.1 credits per message (one message per delivered transaction). 4. **LaserStream gRPC at `processed`** — post-execution with commitment guarantees. ## Guides All-guides index: https://www.helius.dev/docs/guides/overview.md ### Getting Started - Quickstart: https://www.helius.dev/docs/quickstart.md - Getting Data: https://www.helius.dev/docs/getting-data.md - Authentication: https://www.helius.dev/docs/api-reference/authentication.md - Endpoints: https://www.helius.dev/docs/api-reference/endpoints.md - Get Devnet SOL: https://www.helius.dev/docs/rpc/devnet-sol.md - Protect Your API Keys: https://www.helius.dev/docs/rpc/protect-your-keys.md ### RPC & Historical Data - getTransactionsForAddress (filtered, paginated transaction history for any address; opt-in token-account activity via `filters.tokenAccounts`): https://www.helius.dev/docs/rpc/gettransactionsforaddress.md - getTransfersByAddress (transfer-level history): https://www.helius.dev/docs/rpc/gettransfersbyaddress.md - Migrate to getTransactionsForAddress: https://www.helius.dev/docs/rpc/migrate-to-gettransactionsforaddress.md - Transaction v1 support (set maxSupportedTransactionVersion: 1, SDK minimums, priorityFee in transactionConfig): https://www.helius.dev/docs/rpc/transaction-v1.md - Historical Data overview: https://www.helius.dev/docs/rpc/historical-data.md - Historical Account API (beta) (getHistoricalAccountInfo, getHistoricalTokenAccountsByOwner: read accounts at any past slot or transaction from epoch 1030 onward): https://www.helius.dev/docs/rpc/historical-accounts.md - Account data: https://www.helius.dev/docs/rpc/accounts.md - Block & network methods: https://www.helius.dev/docs/rpc/other-methods.md - How to Index Solana Data: https://www.helius.dev/docs/rpc/how-to-index-solana-data.md - RPC optimization (performance & cost): https://www.helius.dev/docs/rpc/optimization-techniques.md - Per-method RPC guides index (50 how-to guides): https://www.helius.dev/docs/rpc/guides/overview.md ### Data Streaming - Data Streaming overview (choosing a delivery model): https://www.helius.dev/docs/data-streaming.md - Data Streaming quickstart: https://www.helius.dev/docs/data-streaming/quickstart.md - LaserStream WebSocket overview: https://www.helius.dev/docs/rpc/websocket.md - LaserStream gRPC quickstart: https://www.helius.dev/docs/laserstream/grpc.md - Historical replay (backfill): https://www.helius.dev/docs/laserstream/historical-replay.md - Delivery guarantees: https://www.helius.dev/docs/laserstream/delivery-guarantees.md - Large-scale account filtering (compressed filters): https://www.helius.dev/docs/laserstream/cuckoo-filters.md - Token account (ATA) filtering: https://www.helius.dev/docs/laserstream/token-account-filtering.md - Token mint filtering (matchMints, subscribe by mint): https://www.helius.dev/docs/laserstream/mint-filtering.md - Transaction monitoring: https://www.helius.dev/docs/laserstream/guides/transaction-monitoring.md - Account subscription: https://www.helius.dev/docs/laserstream/guides/account-subscription.md - Slot & block monitoring: https://www.helius.dev/docs/laserstream/guides/slot-and-block-monitoring.md - Stream Pump AMM data: https://www.helius.dev/docs/laserstream/guides/stream-pump-amm-data.md - LaserStream vs Dedicated Nodes: https://www.helius.dev/docs/laserstream/laserstream-vs-dedicated-nodes.md - Preconfirmations: https://www.helius.dev/docs/pre-confirmations/overview.md ### Sending Transactions - Sender Max: https://www.helius.dev/docs/sending-transactions/sender-max.md - Sender SWQOS-Only: https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md - Send transactions (basic): https://www.helius.dev/docs/sending-transactions/send-manually.md - Send bundles (basic): https://www.helius.dev/docs/sending-transactions/send-bundle.md - Optimizing transactions: https://www.helius.dev/docs/sending-transactions/optimizing-transactions.md - Backrun rebates (earn SOL): https://www.helius.dev/docs/sending-transactions/backrun-rebates.md - Jupiter Swap API via Sender: https://www.helius.dev/docs/sending-transactions/jupiter-swap-api-via-sender.md ### Assets & Wallet Data - Get NFTs (assets, collections, proofs): https://www.helius.dev/docs/das/get-nfts.md - Get SPL tokens: https://www.helius.dev/docs/das/get-tokens.md - Search assets: https://www.helius.dev/docs/das/search.md - DAS pagination: https://www.helius.dev/docs/das/pagination.md - Fungible token extension: https://www.helius.dev/docs/das/fungible-token-extension.md - Wallet API overview: https://www.helius.dev/docs/wallet-api/overview.md - Wallet balances: https://www.helius.dev/docs/wallet-api/balances.md - Historical balance at a timestamp/slot: https://www.helius.dev/docs/wallet-api/balance-at.md - Wallet transaction history: https://www.helius.dev/docs/wallet-api/history.md - Wallet transfers: https://www.helius.dev/docs/wallet-api/transfers.md - Wallet identity lookup: https://www.helius.dev/docs/wallet-api/identity.md - Wallet funding source: https://www.helius.dev/docs/wallet-api/funded-by.md ### Webhooks & Priority Fees - Webhooks quickstart: https://www.helius.dev/docs/webhooks/quickstart.md - Webhook transaction types: https://www.helius.dev/docs/webhooks/transaction-types.md - Priority fees via account keys: https://www.helius.dev/docs/priority-fee/estimating-fees-using-account-keys.md - Priority fees via serialized transaction: https://www.helius.dev/docs/priority-fee/estimating-fees-using-serialized-transaction.md ### Trading & Staking - Trading on Solana with Helius: https://www.helius.dev/docs/trading/overview.md - Programmatic staking with the Helius SDK (0% commission validator): https://www.helius.dev/docs/staking/how-to-stake-with-helius-programmatically.md ### Billing - Autoscaling: https://www.helius.dev/docs/billing/additional-credits.md - Pay with Crypto: https://www.helius.dev/docs/billing/pay-with-crypto.md - Unpaid Invoices: https://www.helius.dev/docs/billing/unpaid-invoices.md ## SDKs Official SDKs that wrap all Helius APIs with type-safe methods and built-in error handling. - TypeScript: https://github.com/helius-labs/helius-sdk - Rust: https://github.com/helius-labs/helius-rust-sdk - SDK Overview: https://www.helius.dev/docs/sdks.md - TypeScript SDK Guide: https://www.helius.dev/docs/sdks/typescript.md - Rust SDK Guide: https://www.helius.dev/docs/sdks/rust.md - Rust SDK Docs: https://docs.rs/helius/latest/helius/ ## Developer Tools - Helius MCP: https://www.helius.dev/docs/agents/mcp.md - Orb Explorer — Solana block explorer by Helius (transactions, tokens, wallets, programs/IDLs, validators): https://orbmarkets.io - Orb tutorials: https://www.helius.dev/docs/orb.md - Orb docs index: https://www.helius.dev/docs/orb/llms.txt - AirShip: https://airship.helius.dev ## Agents AI agent documentation, including programmatic signup, API guidance, MCP skills, and SDK usage. - Agents Index: https://www.helius.dev/docs/agents/llms.txt - Agents Overview: https://www.helius.dev/docs/agents/overview.md - Helius CLI: https://www.helius.dev/docs/agents/cli.md - Helius MCP: https://www.helius.dev/docs/agents/mcp.md - Build Skill: https://www.helius.dev/docs/agents/skills/build.md - Phantom Skill: https://www.helius.dev/docs/agents/skills/phantom.md - Jupiter DeFi Skill: https://www.helius.dev/docs/agents/skills/jupiter.md - DFlow Trading Skill: https://www.helius.dev/docs/agents/skills/dflow.md - OKX Trading & Intelligence Skill: https://www.helius.dev/docs/agents/skills/okx.md - SVM Skill: https://www.helius.dev/docs/agents/skills/svm.md - Claude Code Plugin: https://www.helius.dev/docs/agents/claude-code-plugin.md - TypeScript SDK for Agents: https://www.helius.dev/docs/agents/typescript-sdk.md - Rust SDK for Agents: https://www.helius.dev/docs/agents/rust-sdk.md ## Resources - Dashboard: https://dashboard.helius.dev - Status: https://helius.statuspage.io - Discord: https://discord.com/invite/6GXdee3gBj - Support: https://dashboard.helius.dev/support - FAQs: https://www.helius.dev/docs/faqs.md (per-product pages at https://www.helius.dev/docs/faqs/{product}.md, where {product} is one of: rpc, laserstream, sender, webhooks, websockets, das-api, accounts, billing, priority-fee, zk-compression, enhanced-transactions, preprocessed-transactions) - Error Codes: https://www.helius.dev/docs/faqs/error-codes.md - Glossary: https://www.helius.dev/docs/glossary.md - RPC Benchmarks: https://www.helius.dev/benchmarks --- ## About Helius | Solana’s Leading Developer Platform _Source: https://www.helius.dev/about.md_ > Helius is a market technology company that builds Solana developer tools and trading infrastructure for crypto startups, trading firms, and financial companies. **About Helius** ## Solana’s leading developer platform Helius is a market technology company that builds Solana developer tools and trading infrastructure for crypto startups, trading firms, and financial companies ## Enable programmable money and markets at planetary scale [Read the manifesto](/blog/manifesto) ## Who founded Helius? Helius was founded in 2022 by Mert Mumtaz, Nicolas Pennie, and Liam Vovk. After meeting at Queen's University and spending their early careers at Coinbase and AWS, they made an exclusive bet to build on Solana. Today, Helius is the leading developer platform and trading infrastructure provider on the network. - **Mert Mumtaz**: Co-founder & CEO Mert is the CEO and co-founder of Helius. Before Helius, he was an engineer at Coinbase working on the ledger, trading infra, and Solana integration teams. At Helius, Mert leads Solana privacy, LanaAI, the Orb block explorer, and experiments. Mert also mentors founders in the Helius Startup Launchpad, judges hackathons, speaks at conferences around the world, and is an active voice in the ecosystem. - **Nicolas Pennie**: Co-founder & COO Nick is the COO and co-founder of Helius. Before co-founding Helius, Nick was an engineer at Amazon Web Services. Nick's focus at Helius is the data platform team, which covers Solana RPCs, archival data, LaserStream gRPC and WSS, the DAS API, parsed events, and other core APIs. - **Liam Vovk**: Co-founder & CTO Liam is the CTO and co-founder of Helius. Before starting Helius, he was an engineer at Amazon, where he focused on building scalable inference pipelines. At Helius, Liam oversees all Solana trading infrastructure, including Preconfirmations, Shred Delivery, Sender, Transaction Rebates, and validator operations. ## Our investors - Founders Fund - Foundation Capital - HAUN - Solana Ventures - Ch. 1 - Reciprocal Ventures - 6th Man Ventures - Propel ## How we help you win We give you the tools and support to reshape how money and markets move ### Trading Spot onchain signals faster and win the latency race to land contested trades - [**Preconfirmations**](https://www.helius.dev/preconfirmations): The earliest Solana transaction signal, streamed over WebSockets - [**Raw Shreds**](https://www.helius.dev/shreds): Unprocessed Solana shreds delivered directly over UDP; requires a deshredder - [**Preprocessed Transactions**](https://www.helius.dev/preprocessed-transactions): Pre-execution transaction data streamed over WSS; we decode shreds for you - [**Sender Max**](https://www.helius.dev/sender): Low-latency landing service that routes transactions across every available high-speed pathway for professional traders ### Data Stream real-time updates or look up any piece of historical data on-demand - [**LaserStream (gRPC and WSS)**](https://www.helius.dev/laserstream): Stream updates for onchain programs, accounts, blocks, transactions in real time - [**Historical Data**](https://www.helius.dev/historical-data): Fast archival data since genesis - [**Parsed Events API and Streams**](https://www.helius.dev/parsed-data): Decoded transaction history and events - [**Token API**](https://www.helius.dev/solana-token-apis): Onchain data for every asset on Solana - [**Wallet API**](https://www.helius.dev/wallet-api): REST endpoints for Solana wallet data - [**Webhooks**](https://www.helius.dev/solana-webhooks-websockets): Event-driven alerts for onchain activty ### Infrastructure Access globally available, enterprise-ready infrastructure that businesses trust - [**RPC Nodes**](https://www.helius.dev/solana-rpc-nodes): Reliable RPC nodes for reads and writes - [**Sender**](https://www.helius.dev/sender): Landing service for everday transactions - [**Validator**](https://www.helius.dev/validator): Stake with us, keep 100% of your rewards - [**White-label Validators**](https://www.helius.dev/validator-as-a-service): Launch a branded validator run by Helius - [**Embedded Wallets**](https://www.helius.dev/docs/waas/overview): Add non-custodial wallets to your app - [**Privacy**](https://www.helius.dev/privacy): Private payments and finance on Solana ## Work at Helius ## Trusted by Solana's best teams ## Frequently Asked Questions ### When was Helius founded? Helius was founded in 2022 by Mert Mumtaz, Nicolas Pennie, and Liam Vovk during the crypto bear market, with an exclusive focus on Solana. ### Where is Helius headquartered? Helius Blockchain Technologies, Inc. is headquartered in Claymont, Delaware. We are a fully remote company with teammates distributed around the world. ### What services does Helius provide? Helius is Solana’s leading infrastructure and developer platform. We provide high-performance [RPC nodes](/solana-rpc-nodes), transaction landing ([Sender](/sender)), data streaming ([LaserStream](/laserstream), [webhooks](/solana-webhooks-websockets), [shreds](/shreds), and [preconfirmations](/preconfirmations)), [historical](/historical-data) and [parsed data](/parsed-data) APIs, [token APIs](/solana-token-apis), [validator infrastructure](/validator), and the [Solana privacy protocol](/privacy). ### How do I contact Helius? Reach our enterprise team on the [Contact us](/contact) page, join us on [Discord](https://discord.com/invite/6GXdee3gBj), or visit [Support](/docs/support). ### How do I join Helius? See open roles on our [Careers](/careers) page. We’re always looking for people who want to accelerate internet capital markets on Solana. ## Join the financial revolution Create your Helius account today, or connect with our team to explore your options. [Get started](https://dashboard.helius.dev/signup) | [Contact us](https://www.helius.dev/contact) --- ## Helius for Agents: Solana Developer Tools _Source: https://www.helius.dev/agents.md_ > The complete toolkit for agents building on Solana — Helius Claude Code Plugin, MCP, Skills, CLI, and optimized SDKs. **Helius for Agents** ## One-shot anything on Solana The complete toolkit for agents building on Solana. One-shot Solana apps using the official Helius Claude Code Plugin, MCP Server, skills, and CLI. [For humans](https://www.helius.dev/docs/agents/overview) | [For agents](https://www.helius.dev/docs/agents/overview.md) ## The most comprehensive AI toolkit for building apps on Solana ## Helius Claude Code Plugin Use every Helius API and tool like an expert directly from Claude Code. Query RPCs, parse transactions, and send transactions without leaving your editor. - Native RPC, WSS, DAS, Sender, and more - Secure API key handling and best practices - No context switching; build and ship in one flow ## Helius MCP Access 60+ Solana operations exposing RPC, DAS, webhooks, and transaction sending to any MCP-compatible AI assistant or agent framework. - Drop-in MCP server for Claude, Codex, and more - 60+ operations for balances, tokens, and transactions - Configure once, use across all agent workflows ## Helius CLI Install the Helius CLI to authenticate and use 95+ Helius commands directly from your terminal. Ideal for scripting, CI/CD, and local agent tooling. - Works with all Helius products - 95+ commands from auth, to reads and writes - Use in scripts and automation via env or config ## Helius SDKs The Official Rust and TypeScript SDKs for Helius, fully optimized and documented for agentic development. - TypeScript and Rust with full type definitions - Fully documented patterns for agentic workflows - RPC, DAS, WebSockets, and transaction helpers ## Want to add a skill? Message our team to integrate your product with our AI toolkit. [Contact us](https://form.typeform.com/to/OcAOlRfw) ## Helius Skills - **undefined**: Official Helius skill for Solana development - **undefined**: DFlow skill for agent-driven trading - **undefined**: Phantom skill for building frontend apps ## Frequently Asked Questions ### What can agents do with Helius? Helius gives AI agents direct access to Solana via the fastest, most reliable infrastructure possible. Query wallet balances, parse and send transactions, monitor addresses via webhooks, stream real-time data, estimate priority fees—the options are endless. Agents can create a Helius account and configure an API key entirely on their own, with no browser needed. ### How do the Helius agent tools work? Helius offers a suite of products that give AI the knowledge and live access it needs to build on Solana. The MCP Server includes 60+ tools that AI agents call directly against Solana. Structured inputs, structured outputs, no shell commands or parsing. It covers all available Helius products and includes autonomous account signup. Works with Claude Code, Cursor, Codex, and any MCP-compatible tool. Skills are instruction sets that make Claude a Solana specialist. Each skill routes your request to the right tools and reference files, follows correct SDK patterns, and avoids common mistakes. Available for general Solana development with Helius (Build), trading apps (via DFlow), frontend apps (via Phantom), and protocol internals (SVM). The Claude Code Plugin bundles the MCP server with expert skills. Install to get live Solana access with deeply informed coding guidance all in one step. The Helius CLI provides shell-level access to the same capabilities as the MCP server. Useful for CI/CD pipelines, scripting, and environments where MCP isn’t available. The TypeScript and Rust SDKs provide type-safe wrappers around Helius APIs for agents so they can call Helius directly from code, without going through an AI tool. ### Which tool should I choose? We recommend using the MCP for most use cases—it works with Claude Code, Cursor, Codex, and any MCP-compatible tool. Use the Claude Code plugin if you’re an avid Claude user and want skills bundled in with the MCP. Use the CLI for shell scripts and CI/CD pipelines where you need terminal-level automation. Use the TypeScript or Rust SDKs to write your own agent and have type-safe API access directly in code. ### Do I need a Helius account before I start? No. An AI agent can [programmatically create a Helius account](https://www.helius.dev/docs/agents/overview#quick-start-agent-signup) for you with your email and name. The agent generates a Solana wallet and starts signup, you pay the $10 USDC one-time Agent plan fee from any wallet via the payment link (or the agent autopays from its funded wallet), and you get an API key and 1,000,000 credits. Existing users can set their API key and use their plan to the fullest across any of our AI tools. ### How much does it cost to use Helius's tools for agents? Getting started on the Agent plan costs $10 USDC one-time, paid on-chain at signup (a valid email is required), and includes 1,000,000 credits. Paid [plans](https://www.helius.dev/docs/billing/plans) start at $49/month for higher rate limits and more credits. Sender, our transaction sending service, is included for free on all plans. ## Ship faster Start using Helius with Claude, Codex, or your own agentic workflows [Get started](https://www.helius.dev/docs/agents/overview) --- ## Helius Brand Kit _Source: https://www.helius.dev/brand.md_ > Follow these brand guidelines when promoting Helius in marketing communications, including advertising, articles, websites, and printed promotions. ## Brand Kit Follow these brand guidelines when promoting Helius in marketing communications, including advertising, articles, websites, and printed promotions. ## Logos Primary logo to use is the horizontal lockup in Helius Orange. You can use others as needed according to contrast or surrounding design. ### Logo Variants | Variant | SVG | PNG | |---------|-----|-----| | Horizontal Orange | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Horizontal-Logo.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Horizontal-Logo.png) | | Vertical Orange | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Vertical-Logo.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Vertical-Logo.png) | | Horizontal White | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Horizontal-Logo-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Horizontal-Logo-White.png) | | Vertical White | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Vertical-Logo-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Vertical-Logo-White.png) | | Horizontal Black | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Horizontal-Logo-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Horizontal-Logo-Black.png) | | Vertical Black | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Vertical-Logo-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Vertical-Logo-Black.png) | | Icon Orange | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Icon.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Icon.png) | | Icon White | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Icon-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Icon-White.png) | | Icon Black | [SVG](https://www.helius.dev/Helius-Brandkit/Helius/Helius-Icon-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Helius/PNG/Helius-Icon-Black.png) | | Orb Horizontal Orange | [SVG](https://www.helius.dev/Helius-Brandkit/Orb/Orb-Horizontal.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Orb/PNG/Orb-Horizontal.png) | | Orb Horizontal White | [SVG](https://www.helius.dev/Helius-Brandkit/Orb/Orb-Horizontal-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Orb/PNG/Orb-Horizontal-White.png) | | Orb Horizontal Black | [SVG](https://www.helius.dev/Helius-Brandkit/Orb/Orb-Horizontal-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Orb/PNG/Orb-Horizontal-Black.png) | | Orb Icon Orange | [SVG](https://www.helius.dev/Helius-Brandkit/Orb/Orb-Icon.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Orb/PNG/Orb-Icon.png) | | Orb Icon White | [SVG](https://www.helius.dev/Helius-Brandkit/Orb/Orb-Icon-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Orb/PNG/Orb-Icon-White.png) | | Orb Icon Black | [SVG](https://www.helius.dev/Helius-Brandkit/Orb/Orb-Icon-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Orb/PNG/Orb-Icon-Black.png) | | Helius Privacy Horizontal White | [SVG](https://www.helius.dev/Helius-Brandkit/Privacy/Helius-Privacy-Horizontal-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Privacy/PNG/Helius-Privacy-Horizontal-White.png) | | Helius Privacy Vertical White | [SVG](https://www.helius.dev/Helius-Brandkit/Privacy/Helius-Privacy-Vertical-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Privacy/PNG/Helius-Privacy-Vertical-White.png) | | Helius Privacy Icon White | [SVG](https://www.helius.dev/Helius-Brandkit/Privacy/Helius-Privacy-Icon-White.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Privacy/PNG/Helius-Privacy-Icon-White.png) | | Helius Privacy Horizontal Black | [SVG](https://www.helius.dev/Helius-Brandkit/Privacy/Helius-Privacy-Horizontal-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Privacy/PNG/Helius-Privacy-Horizontal-Black.png) | | Helius Privacy Vertical Black | [SVG](https://www.helius.dev/Helius-Brandkit/Privacy/Helius-Privacy-Vertical-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Privacy/PNG/Helius-Privacy-Vertical-Black.png) | | Helius Privacy Icon Black | [SVG](https://www.helius.dev/Helius-Brandkit/Privacy/Helius-Privacy-Icon-Black.svg) | [PNG](https://www.helius.dev/Helius-Brandkit/Privacy/PNG/Helius-Privacy-Icon-Black.png) | [Download All Logos](https://www.helius.dev/Helius-Brandkit.zip) ## Colors Helius colors consist of Brand Orange and neutral colors. | Color | Hex | HSL | |-------|-----|-----| | Orange | #E84125 | HSL: 9 81 53 | | Black | #090909 | HSL: 0 0 4 | | White | #DBDBDB | HSL: 0 0 86 | ## Clearspace When using the Helius logomark or wordmark, it's important to ensure a generous margin to prevent it from becoming cluttered by surrounding artwork, images, or the edge of a page. ### Wordmark x = Height of the wordmark ### Logomark x = Height of the logomark --- ## Careers at Helius: Solana's Top Development Platform _Source: https://www.helius.dev/careers.md_ > Explore open roles, and join our mission to enable programmable money and markets at planetary scale. ## Careers at Helius Shape the future of the internet and Solana by building at the frontier of high-scale, low-latency distributed systems. [View open positions](#open-positions) ## Enable programmable money and markets at planetary scale Accelerate internet capital markets on Solana. Build high-performance infrastructure and developer tooling to scale crypto's most ambitious startups. ## Backed by top investors - Founders Fund - HAUN - Ch. 1 - Reciprocal Ventures - 6th Man Ventures - Foundation Capital - Anatoly Yakovenko - Balaji Srinivasan ## What's unique about working at Helius? - Develop the frontier of high-scale, low-latency distributed systems in adversarial environments with high stakes - Scale crypto and blockchain holistically, from first principles - Build and accelerate the first global financial computer - Increase the economic potential of the world - Update the financial system ## Operating principles - **Faster**: This is the main principle behind everything we do. Speed is the default behind every decision. Everything can be faster: API calls, customer support, meetings, calls, sales cycles, and even your typing speed. - **Divine Discontent**: Nothing is more demoralizing for winners than mediocrity. Do not let yourself or your colleagues ever ship something they're not excited about. If it's not a 10/10, try again. - **Clear Communication**: Maximize context per sentence, add TL;DRs, don't use fluff words. Default to directness over superficial politeness. No typos. Respect the reader and their time. - **Assertive Action**: We are not bureaucrats, we are builders. We don't get feedback from academic journals, we get feedback from customers. Ship something, get it out, get feedback. Take action. - **Win**: We are here to win. Not to participate, not to be comfortable, but to win. Set the bar high, measure yourself against the best, and push beyond what seems possible. - **Optimism**: If you don't believe that the future can look better than the past, you have picked the wrong company. Reframe all "problems" with "opportunity". We keep the bar high because we are fundamentally optimistic about human potential. ## Company perks - **Fully remote**: Internet capital markets are global and online 24/7. So is our team. Work from anywhere while building the future of finance. - **Partner offices**: Access partner offices in 7 global cities: SF, LA, Chicago, NYC, Dubai, Singapore, and Tokyo. Perfect for deep work and meetups. - **Flexible schedule**: Execution is everything. Design your schedule for peak productivity and delivering results. Crypto is not a "9-5," and neither are we. - **Wellness budget**: Be unstoppable. Use our annual wellness budget to optimize your performance. From gym memberships to meditation apps – peak health fuels peak execution. - **Event budget**: Experience Solana's community IRL. Use our annual event budget to meet teammates and builders at conferences, hacker houses, and events. - **Learning budget**: Sharpen your edge to win. Use our annual learning budget to accelerate your personal and professional growth with books, courses, AI developer tools, and more. ## Join us --- ## Historical Solana Data API for Indexing and Backfills _Source: https://www.helius.dev/historical-data.md_ > Build indexes up to 10x faster and eliminate complicated backfill workflows with custom archival Solana RPC methods and streaming tools. **Historical Data** ## Fast archival data for backfills and indexing Query historical Solana data up to 10x faster with our state-of-the-art archival system and exclusive RPC methods like getTransactionsForAddress. [Get started](https://www.helius.dev/docs/rpc/historical-data) **SOLANA ARCHIVAL** ## 10x lower latency, 100x fewer RPC calls Easily access Solana's entire history since genesis, and build backend services with confidence. ## Historical data use cases - **Indexing**: Quickly seed your database with archive data without having to build an indexer. - **Compliance**: Get historical transaction activity to comply with regulations and regulatory agencies. - **Backtesting**: Download datasets to test trading algorithms, improve ROI, and reduce risk. - **Historical Analysis**: Uncover onchain trends, flows, and user behavior by analyzing structured datasets. - **Reporting**: Backfill historical application and revenue data to ensure accurate reporting. - **Training**: Use structured data to train LLMs on a complete, searchable Solana dataset. ## Access Solana's entire history with one RPC call Index data easier with getTransactionsForAddress, a new method that combines getSignaturesForAddress and getTransaction into a single call. - Use reverse search to return the oldest results first - Add time-based filters to filter by timestamp or slot - Get a unified history for addresses and token accounts [View docs](https://www.helius.dev/docs/api-reference/rpc/http/gettransactionsforaddress) **See also:** - [Introducing the tokenAccounts Filter](https://www.helius.dev/blog/solana-token-accounts-history): Learn how to get an address's entire history in 1 call ## Full wallet transfer history,
no stitching required Use getTransfersByAddress to return parsed, human-readable SOL and token transfer records for a wallet address with precise filters. - Filter transfers by mint, time, amount, slot, status, direction, or counterparty - Return concise human-readable transfer objects instead of full transaction payloads - Fetch the whole wallet transfer history with pagination built for production apps [View docs](https://www.helius.dev/docs/api-reference/rpc/http/gettransfersbyaddress) **See also:** - [Wallet API](https://www.helius.dev/wallet-api): REST endpoints for balances, identities, and activity ## Solana indexing,
now 10x faster Backfill your databases with historical data 10x faster using our performance-optimized archival system, and use LaserStream to keep data fresh. - 8ms P50 lookup times under production load - Runs on bare metal with petabyte-scale NVMEs - Replicated across multiple regions for redundancy **See also:** - [LaserStream](https://www.helius.dev/laserstream): Low-latency gRPC data streaming > "Pulling Solana transactions into Awaken's tax tool from wallets with over 15,000 transactions used to take 3-5 minutes. With getTransactionsForAddress it takes less than 60s. Plus, with gTFA's slot-based filtering, we can continuously sync new transactions from the last imported slot faster and easier than traversing backwards from newest to oldest." — **Andrew Duca**, FOUNDER AND CEO, AWAKEN, Awaken ## Frequently Asked Questions ### What does backfill and indexing mean? Indexing, in the context of Solana archival data, is the process of structuring and organizing historical transaction data into a database for fast, efficient, retrieval. Most companies building products on Solana will maintain indexes related to their business (e.g., stablecoin transfers). Backfilling is the process of retrieving historical transaction data from any point in time since Solana’s genesis block to build an index. In most cases, developers can use an RPC method like [getTransactionsForAddress](/docs/api-reference/rpc/http/gettransactionsforaddress) to apply time-based filters, set sort order (i.e., chronologically vs. newest first), and paginate over batches of transactions. For large backfills, companies can reach out to our team for [managed backfills](https://form.typeform.com/to/Apcdje4f). ### What is the difference between self-serve and managed backfill? Self serve allows you to backfill or index Solana data using existing RPC methods like our enhanced [getTransactionsForAddress](/docs/api-reference/rpc/http/gettransactionsforaddress) to land the data in your preferred destination. Managed backfill is a beta offering where we handle the above process for you. We are limiting access to the managed backfill service to a limited number of customers initially to better understand the pain points and desired destination for backfill data before rolling it out as a self-serve option. ### How do I index Solana data? The recommended method for [indexing Solana data](/docs/rpc/how-to-index-solana-data) is to use the getTransactionsForAddress RPC method to get all of Solana's archival data, store it in the database of your choice like PostgreSQL or a columnar database like ClickHouse, and then use a Solana data streaming solution like [LaserStream](/docs/laserstream/grpc) or [Enhanced WebSockets](/docs/rpc/websocket) to keep your index updated in real time. ### What is the getTransactionsForAddress (gTFA) RPC method? The getTransactionsForAddress (gTFA) RPC method is a Helius-exclusive [Solana RPC method for querying archival data](/docs/rpc/gettransactionsforaddress) that combines getSignaturesForAddress and getTransaction into a single call. Developers can use powerful new features including reverse search, time, status, and slot-based filtering, and pagination to return batches of up to 100 full transactions or 1,000 signatures. ### What is the tokenAccounts filter for gTFA? The [new tokenAccounts filter](/blog/solana-token-accounts-history) for getTransactionForAddress returns all of the transactions for a Solana address — including all of the transactions involving the address's Associated Token Accounts (ATAs) — with a single call. Previously, developers needed to query getTokenAccountsByOwner and then getSignaturesForAddress for every token account, which was slow, expensive, and often required 100s of extra RPC calls. ### Can I get a wallet's history already parsed into human-readable data? Yes. For a full picture, use the [Parsed Events API](https://www.helius.dev/parsed-data) to page through an address's history with supported instructions decoded into named arguments and accounts across over 3,600 Solana programs, plus token-transfer details and plain-language summaries where supported. Raw instruction data is retained when decoding is unavailable. Use getTransactionsForAddress when you need the raw transaction payloads. You can also use getTransfersByAddress to return concise, parsed SOL and token transfer records for an address. ### How do I get the entire history of a Solana wallet? To get the entire history of a Solana wallet, including all of it's Associated Token Accounts (ATAs), use the getTransactionsForAddress RPC method and set the tokenAccounts filter to all. This requires that returned transactions reference the address of the wallet or a token account owned by the wallet. For more information, read our guide about [getting Solana token history](/docs/rpc/gettransactionsforaddress#get-token-history-in-one-call) in one call. ### Why is Helius’s archival system up to 10x faster than other archival solutions? We built a [brand new Solana archival system](https://www.helius.dev/blog/introducing-gettransactionsforaddress) from scratch to replace the default Google BigTable database which most other RPC providers use to serve historical data. Our index stores one entry per unique (transaction, account) pair. To date, our index has over 2.3 trillion rows which hold Solana’s more than 450 billion transactions as of this writing. Despite the size, the P50 lookup time is approximately 8ms under production load. We also built other indices to power lookups by slot, time, status, and more. All of these indices run on purpose-built, bare metal hosts with petabytes of top-of-the line NVMEs, replicated across multiple regions to provide developers with reliable, scalable, and low-latency access to historical data. ### How does gTFA improve historical data querying vs. standard Solana RPC methods? Standard RPC methods like getBlock are slow and not suitable for small, specific datasets. Looping methods like getSignaturesForAddress and getTransaction require lots of unnecessary RPC requests, exponential backoffs, and retry logic. Until now, these standard RPC methods also hit Google BigTable, the default archival datastore used by most RPC providers. We built our own index from scratch to optimize how historical data is stored, accessed, and served. When developers query the getTransactionsForAddress (gTFA) method, they are combining the standard getSignaturesForAddress and getTransaction methods into a single query with additional sorting, filtering, and pagination options. Because we built custom indexes, getTransactionsForAddress gives developers more control over their queries, simplifies workflows, and returns data faster. ### How can I get started with the Historical Data APIs? To get started, explore these resources: - [Historical Data Documentation Overview](/docs/rpc/historical-data) - [getTransactionsForAddress Guide](/docs/rpc/gettransactionsforaddress) - [getTransfersByAddress Guide](/docs/rpc/gettransfersbyaddress) - [getTransactionsForAddress API Reference](/docs/api-reference/rpc/http/gettransactionsforaddress) - [How to Index Solana Data](/docs/rpc/how-to-index-solana-data) ## Start querying Solana history Build faster with Helius-only historical methods and low-latency archival infrastructure. [Start building](https://dashboard.helius.dev/signup) --- ## Helius: Solana's Leading RPC and API Platform _Source: https://www.helius.dev/home.md_ > Solana RPCs, APIs, gRPC, webhooks, and dedicated infrastructure to build and ship crypto apps, fast. Get started for free in 1 click. ## The engine behind Solana's best teams, traders, and tinkerers. Solana’s most reliable and low latency RPCs, transaction landing services, and data streaming tools. [Start for free](https://dashboard.helius.dev/signup) | [Documentation](https://www.helius.dev/docs) **THE COMPLETE STACK** ## The API for Internet Markets Run your apps and trading strategies on a unified platform that combines low latency reads with optimized transaction delivery pipelines to detect onchain signals faster, fill more trades, and reduce engineering time. ## LaserStream The fastest, most reliable way of streaming Solana blocks, transactions, and account data via gRPC. - Extreme Redundancy — redundant node clusters with historical replay and persistence so you never miss data - Optimized ShredStream — receive data before anyone else without running your own dedicated nodes - Global Coverage — regional endpoints for FRA, AMS, TYO, SG, LAX, LON, EWR, PITT, and SLC [Get started](https://www.helius.dev/laserstream) **See also:** - [LaserStream WebSockets](https://www.helius.dev/solana-webhooks-websockets): Listen to onchain events and stream updates ## Sender Reliably land transactions even during the toughest market conditions with our ultra-low latency transaction sending service. 0 API credits. 7 global endpoints. 50 TPS (default). Optimized for traders. - Route txns across every available high-speed pathway - Submit transactions through 7 regional endpoints - Access staked bandwidth from [Solana's #1 validator](https://www.helius.dev/validator) [Get started](https://www.helius.dev/sender) **See also:** - [Preconfirmations (Preconfs)](https://www.helius.dev/preconfirmations): The earliest trading signal on Solana ## Solana RPCs The fastest path to Solana via globally distributed RPCs and our Gatekeeper edge gateway. - Sub-millisecond responses via [Gatekeeper](https://www.helius.dev/blog/introducing-gatekeeper), our Rust-based edge gateway - Helius-exclusive [archival methods](https://www.helius.dev/historical-data) with cursor-based pagination like getTransactionsForAddress - Send transactions via [staked connections](https://www.helius.dev/staked-connections) by default [Get started](https://www.helius.dev/solana-rpc-nodes) **See also:** - [Benchmark Solana RPC Providers](https://www.helius.dev/benchmarks): Test RPC latency across methods, regions, and infra ## Enterprise-grade infrastructure and reliability We detect your problems before you do. The biggest apps in crypto rely on our SOC 2 certified infrastructure and Solana-native experience to meet their every scaling challenge. When you choose us, everything just works. - **RPC success rate**: 99.99% - **Transaction confirmations**: 5x faster - **Continents covered**: 3 - **Support available**: 24/7 ### Tailored solutions just for you No two companies are the same. Book a meeting with our team, and we'll create a custom plan for your business. [Schedule a call](https://www.helius.dev/contact) | [Chat with us](https://t.me/dtalw) ### SOC Compliant SOC 2 certified infrastructure ## Solutions for any business - **Traders & Market Makers**: Combine the lowest latency shreds with the fastest transaction delivery service to find signals faster and win more trades. - **Crypto Exchanges**: Run your exchange on the most scalable and reliable Solana tech stack so you can handle even the most active trading days onchain. - **Searchers**: Discover opportunities and land bids faster than your competitors with a unified trading stack engineered for speed and simplicity. - **Wallets**: Create a wallet experience users love with the freshest account balances, real-time notifications, and industry-leading reliability. - **DeFi**: Build performant apps for internet capital markets on purpose-built infrastructure for low latency reads and writes. - **Fintech**: Launch new payments, banking, and stablecoin apps on a platform with unmatched availability and scale. ## Trusted by Solana's best teams > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana. They power a great portion of our infrastructure at Backpack." — **Armani Ferrante**, CO-FOUNDER & CEO, BACKPACK > "The Helius team makes building on Solana smoother and easier. They've done an amazing job at streamlining and removing complexity from app development on the network." — **Anatoly Yakovenko**, CO-FOUNDER & CEO, SOLANA > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM > "The Helius team is the GOAT. They ship fast, intake product feedback overnight, and power a great deal of Crossmint infrastructure. A big percentage of Crossmint products couldn't exist without Helius." — **Alfonso Gomez Manas**, CO-FOUNDER, CROSSMINT > "Having personally built our own in-house indexing and data pipelines at Zeta, I know how much of a headache it is for new teams. Being able to save countless hours of data engineering work and costly AWS bills is a big advantage for us." — **Tristan Frizza**, FOUNDER & CEO, ZETA MARKETS > "Helius has been instrumental in kickstarting our Pythnet operations. Their seamless infrastructure management ensures everything runs smoothly, allowing us to focus on building and scaling our trading operations without worrying about the details of running Solana nodes." — **Jeremy De Groodt**, CO-FOUNDER & CTO, KEYROCK > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." — **Jonathan Levin**, CEO AND CO-FOUNDER, CHAINALYSIS > "We tried every strategy to land transactions on Solana, but nothing was working. The moment we switched our RPCs to Helius and started sending transactions through staked connections, all of our problems disappeared. Now we can confidently scale our business on Solana without worrying about our customer's transactions getting dropped." — **Cody Lambert**, SOFTWARE ENGINEER, BRALE > "When it comes to SOL staking, Helius is truly differentiated. Helius is the industry leader when it comes to running secure, reliable, and performant validators. Since launching in 2022, they have championed Solana's success, built world-class infrastructure, and stewarded the network to become what it is today - the foundation on which the new financial system will be built." — **Cosmo Jiang**, GENERAL PARTNER AT PANTERA CAPITAL AND BOARD OBSERVER AT HSDT > "We're thrilled to partner with Helius in building our own Solana validator for the Bitwise Solana Staking ETF. Not only is Helius the standard bearer for Solana validators when it comes to areas like performance, reliability, and security, but their native understanding of Solana and its ecosystem is unmatched. They've helped us build the perfect high performance validator—one that meets our stringent needs around security and reporting as an ETF issuer." — **Hong Kim**, CTO, BITWISE ASSET MANAGEMENT > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." — **Nitesh Nath**, CEO, DFLOW ## Ready to build? Get started in less than 10 seconds. No credit cards or email required. [Start building](https://dashboard.helius.dev/) | [Learn more](https://www.helius.dev/docs) --- ## LaserStream: Real-time Solana data streaming _Source: https://www.helius.dev/laserstream.md_ > Low-latency and fault-tolerant alternative to Yellowstone gRPC and WebSockets with new features such as historical replay. **LaserStream** ## Stream Solana blocks, accounts and transactions — faster LaserStream is a reliable, low-latency, and fault-tolerant alternative to Yellowstone gRPC. [Start building](https://dashboard.helius.dev/signup) | [Documentation](https://www.helius.dev/docs/laserstream) ## Reliable, low-latency event streaming for traders and real-time apps ## Faster indexing with LaserStream & Helius Archival - **1. Backfill archival data**: Use getTransactionsForAddress to get all historical data for a specific program or account on Solana with powerful time-based filtering, bidirectional sorting, and pagination. - **2. Keep indexes fresh**: Use LaserStream to keep Solana indexes updated in real-time with reliable, low-latency streams, automatic reconnects, and historical replay (up to 48 hours). ### getTransactionsForAddress ```json { "jsonrpc": "2.0", "id": 1, "method": "getTransactionsForAddress", "params": [ "TARGET_WALLET_ADDRESS", { "transactionDetails": "full", "sortOrder": "asc", // Oldest first "limit": 1000 } ] } ``` [Get started](https://www.helius.dev/docs/rpc/gettransactionsforaddress) ## Who is LaserStream for? - **Traders & market makers**: Instantly receive updates for slots, accounts, and Solana programs for low-latency trading. - **Searchers & MEV Bots**: Ingest onchain data to execute profitable trades and arbitrages and before competitors. - **Memecoin sniper bots**: Stream program updates as soon as they're processed to snipe brand new tokens. - **Wallets**: Give users responsive, real-time price data, updates, transaction alerts, and activity logs. - **Real-time portfolio trackers**: Provide users with up-to-date information on their open positions, PnLs, and tokens. - **Onchain analytics**: Get the most accurate view of what's happening on Solana with real-time data. ## How DFlow Uses LaserStream to Quote Solana's Best Prices See how DFlow, a leading DEX Aggregator on Solana eliminated engineering overhead, achieved 100% uptime, and recorded the single best month of swap volume in protocol history. [Read now](https://www.helius.dev/blog/dflow) ## Real-time Solana data engineered for scale Power your trading systems and latency-sensitive apps with accurate, onchain data at Solana speeds. - Ultra low latency: LaserStream ingests raw shreds to give you the earliest visibility into state updates - Pre-execution data: pair with [Preprocessed Transactions](https://www.helius.dev/preprocessed-transactions) to get transactions up to 8ms faster, decoded directly from shreds - High throughput: easily stream full blocks, millions of wallets, and Solana's most used programs - Optimized SDKs: stream up to 1.3GB/s of data with our high-performance [JavaScript client](https://www.helius.dev/docs/laserstream/clients) [View docs](https://www.helius.dev/docs/laserstream) ## Never disconnect, miss data, or go offline Speed and reliability are not tradeoffs. LaserStream's redundant architecture, automatic failovers, and resilient design guarantee high availability. - Redundant: each region has multiple LaserStream servers backed by multiple Solana nodes - Reliable: automatic reconnects and [48-hour historical replay](https://www.helius.dev/docs/laserstream/historical-replay) for uninterrupted, complete data - Distributed across 9 regions including FRA, AMS, TYO, SG, EWR, PITT, SLC, LAX, and LON > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." > — Nitesh Nath, CEO, DFlow ## Focus on building, not infrastructure management Eliminate the complexity of running your own Solana data infrastructure. LaserStream handles all the heavy lifting so you can focus on your product. - No dedicated nodes: get faster gRPC streams without the headaches of managing hardware - Reduce engineering overhead: no manual maintenance or version upgrades required - Minimal diff: fully compatible with the Yellowstone gRPC interface > "LaserStream was a seamless drop-in replacement for Geyser gRPC. It integrated perfectly with Jupiter infra and performed impressively fast." > — Aryan, Co-founder @ SendAI ## Frequently Asked Questions ### How fast is LaserStream? Want to compare LaserStream vs. your existing solution? Use our [latency testing guide](/docs/laserstream/guides/measuring-latency) to see how LaserStream performs. ### Why should I use LaserStream vs. Dedicated nodes? LaserStream is the [recommended choice](/docs/laserstream/laserstream-vs-dedicated-nodes) for virtually all streaming use cases because it is faster, more reliable, easier to manage, and has more advanced features (e.g., 48-hour historical replay and auto-reconnects) compared to dedicated nodes. ### When should I use LaserStream vs. Shred Delivery? Both LaserStream and Shred Delivery are fed with low latency shreds. [Shred Delivery](https://www.helius.dev/shreds) is for teams that want raw, unprocessed shreds and can ingest UDP, deshred packets, and parse everything themselves. [LaserStream](/laserstream) is for teams that want processed, confirmed, and finalized on-chain events delivered with ultra-low latency and automatic recovery for backend paths where correctness matters. ### When should I use LaserStream gRPC vs. WebSockets? For any use case where latency and reliability is important (e.g., trading, exchanges, DeFi, wallets, etc.), LaserStream gRPC is the [recommended streaming solution](https://www.helius.dev/blog/solana-shreds#streaming-data-on-solana). If latency, continuity, and correctness does not affect PnL, fills, or risk, LaserStream Websockets are a good alternative for browser apps, dashboards, or notifications. ### Does LaserStream support preprocessed transactions (i.e., decoded shreds)? LaserStream Preprocessed (gRPC) is being deprecated in favor of [Preprocessed Transactions](/preprocessed-transactions), a standalone WebSocket stream of decoded shreds available on all paid plans at 0.1 credits per message. It delivers signed transactions before they are processed by the rest of the network, which is ideal for low-latency applications that don't have custom deshredding logic. Because the data is pre-execution, it does not include execution metadata like balance changes, logs, or error information. If you're using LaserStream Preprocessed today, please migrate — see the [Preprocessed Transactions docs](/docs/preprocessed-transactions/overview) to get started. ### Does LaserStream support consumer groups? We don’t implement consumer groups. Instead, LaserStream delivers the same outcomes teams want: resume, replay, and multi-node reliability without a coordination layer (and the latency/overhead that comes with it). We believe consumer groups are not needed for most workloads and they add latency and operational overhead. As an example a single LaserStream gRPC connection can emit up to 10× Solana’s transaction + account data, and most clients subscribe to a small, filtered slice. Using consumer groups in this case burns performance headroom and introduces another point of failure. ### What LaserStream data add-on plans are available, and how much do they cost? [Data add-on plans](/docs/billing/plans#data-add-ons) for LaserStream include: 5TB ($400/mon), 10TB ($750/mon), 25TB ($1,750/mon), 50TB ($3,250/mon), and 100TB ($6,000/mon). For larger data add-ons and volume-based pricing, please [contact sales](https://form.typeform.com/to/KiacmxpZ). ### How can I get started with LaserStream? To get started, explore these resources: - [LaserStream Documentation Overview](/docs/laserstream) - [LaserStream gRPC Quickstart](/docs/laserstream/grpc) - [LaserStream API Reference](/docs/api-reference/laserstream-grpc) - [LaserStream gRPC Subscribe Reference](/docs/api-reference/laserstream/grpc/subscribe) - [LaserStream Historical Replay](/docs/laserstream/historical-replay) ## Ready to build? Get your LaserStream URL in your dashboard and start streaming. Available on Business plans and higher. [Start building](https://dashboard.helius.dev/laserstream) | [View docs](https://www.helius.dev/docs/laserstream) --- ## Parsed Events & Streams: Decoded Solana Transactions _Source: https://www.helius.dev/parsed-data.md_ > Parse Solana transactions into named instructions, transfers, and summaries. Query via REST, GraphQL, or stream over WSS. **Parsed Events & Parsed Streams** ## Human-readable Solana data Get decoded transaction details for over 3,600 Solana programs on demand via REST or stream parsed onchain updates via WebSockets. [Get started](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/parsed-streams) **FULLY DECODED TRANSACTIONS** ## The clearest picture of what's happening onchain Turn opaque bytes and accounts into human-readable transaction summaries with descriptive arguments, named accounts, and all token transfers for over 3,600 onchain programs. ### What the chain gives you ```json { "programId": "JUP6LkbZbjS1jKKwapdHNy74...", "data": "EeywBCUuyt2UqWRr9dkkI8hiFZLpJ...", // opaque bytes "accounts": [ "7iWnBRRhBCiNXXPhq1GzvVk...", "GV6UUmNxz2RpKxmNApadYKb7...", "teBPkZtsnaKDpGHTy1KUZeh1...", "2oL6my4QDDCFpgJZX1bZV1Ng...", "9RzosLeV5P5oG5MLobJWrBTG...", "3zExK5UQlKAri2KAAFUTvZAt...", "5tKq8vHmRy3NdWZfLpXo2bAc...", "Hj4nPwEs7YuDgvT6kMxCq9Fb...", … 10 more bare addresses ] } ``` ### What Helius gives you ```json { "programName": "jupiter", "instructionName": "shared_accounts_route_v2", "summary": { "type": "swap", "description": "GV6UUm… swapped 1500 SOL for…", "parsedData": { "protocol": "jupiter", "in_amount": "1500000000000", "actual_out_amount": "64672839261950", "input_mint": "So1111…", // SOL "output_mint": "PumpCm…", // PUMP "inner_swaps": [ … 5 route hops … ] } }, "decoded": { "args": { "slippage_bps": 2200, "route_plan": […] }, "accounts": [ { "name": "user_transfer_authority" } … ] } } ``` ## Solana, deciphered - **1. Look up program instructions**: Use `describeProgram` to look up programs in our IDL catalog and use the named instructions, accounts, and roles to define your server-side filters - **2. Connect and authenticate**: Connect to the filtered stream endpoint, and authenticate with your project’s API key - **3. Start streaming parsed data**: Send a `parsedTransactionSubscribe` request with your filters to start receiving data ### describeProgram ```json { "jsonrpc": "2.0", "id": 1, "result": { "id": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4", "name": "jupiter", "instructions": [ "route", "shared_accounts_route", "exact_out_route" ], "events": ["SwapEvent"], "roles": [ "user_transfer_authority", "destination_token_account" ] } } ``` [Get started](https://dashboard.helius.dev/signup) [View docs](https://www.helius.dev/docs/parsed-streams/quickstart) ## What you can build with parsed Solana data - **Wallet activity feeds**: Page a wallet's parsed history and render transfers, swaps, and summaries instead of decoding raw instructions yourself - **Real-time swap tracking**: Subscribe to router instructions and read in-amount, out-amount, and mints from the decoded payload as swaps land - **Token launch monitoring**: Watch Pump.fun `create` instructions in real time, or page a creator's wallet to list every mint it has ever deployed - **Portfolio and PnL**: Use native and token transfers plus swap summaries to keep balances, positions, and realized PnL up to date - **Trading bots and alerts**: Filter by program, instruction name, or account role so your bot only responds to the actions it cares about - **Indexers and backfills**: Backfill a database with Parsed Events, then keep it updated with real-time transactions from Parsed Streams ## Parse any Solana transaction on demand Turn signatures and address history into decoded instructions, transfers, and summaries for over 3,600 onchain programs. Supports REST and GraphQL. - No raw bytes or unnamed accounts - Filter & page address history by slot, time, or signature - Receive exactly the fields you need with GraphQL, or get the fully translated payload via REST [Get started](https://www.helius.dev/docs/parsed-events/quickstart) [View docs](https://www.helius.dev/docs/parsed-events) **See also:** - [Parsed Events API Quickstart](https://www.helius.dev/docs/parsed-events/quickstart): Parse a signature or page through a wallet's history ## Find any transaction across any address's history Scan an address's history server-side by program instruction or mint, and return fully parsed matches. - Scan up to 10,000 transactions per request - Narrow results by token mint address, time, slot, signature, status, or sort order - Match top-level or inner instructions by program ID, instruction name, or discriminator [Get started](https://dashboard.helius.dev/signup) [View docs](https://www.helius.dev/docs/api-reference/parsed-events/scan) **See also:** - [Try the Parsed Event Scan API Demo](https://dashboard.helius.dev/parsed-events): Access the interactive demo in your dashboard ## Subscribe to decoded transactions in real time Watch every confirmed transaction, filter at the instruction level, and receive the whole transaction already decoded over WebSocket. - Filter by program, instruction, or account - Server-side matching across 3,600+ programs, including inner instructions - Every notification includes a summary, transfers, and pointers to the instructions that matched [Get started](https://www.helius.dev/docs/parsed-streams/quickstart) [View docs](https://www.helius.dev/docs/parsed-streams) **See also:** - [Parsed Streams Quickstart](https://www.helius.dev/docs/parsed-streams/quickstart): Configure your first stream ## Frequently Asked Questions ### On what plans are Parsed Events and Parsed Streams available? The Parsed Events API and Parsed Streams are available on all [plans](/docs/billing/plans), including Free. To get started, get your API key from your Helius Dashboard and follow the quickstart guides in our docs. ### How many credits does the Parsed Events API and Parsed Streams cost? Parsed Events costs 10 credits per request. Parsed Streams costs 1 credit per delivered event. ### How do I figure out the programs in the IDL catalog and their instructions? Use the [describeProgram method](/docs/parsed-streams/quickstart#discovery) to look up an onchain Solana program by its address. If the program has been decoded, you will get the exact instruction and role names with which you can build your filter. ### How do I migrate from the Enhanced Transactions API to the Parsed Events API? Because the Enhanced Transactions API will be deprecated, developers are encouraged to migrate to the Parsed Events API. To migrate, follow [our guide](/docs/parsed-events/guides/migrate-from-enhanced-transactions) to map endpoints, parameters, and response fields. We've also included a prompt for agents to complete the migration for you. ### How can I get started with the Parsed Events API and Parsed Streams? To get started, explore these resources: - [Parsed Events Documentation Overview](/docs/parsed-events) - [Parsed Events Quickstart](/docs/parsed-events/quickstart) - [Parsed Events API Reference](/docs/api-reference/parsed-events/overview) - [Parsed Streams Documentation Overview](/docs/parsed-streams) - [Parsed Streams Quickstart](/docs/parsed-streams/quickstart) ## Get started The Parsed Events API and Parsed Streams are available on all plans [Start building](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/parsed-events) --- ## Solana Preconfirmations: The Earliest Transaction Signal _Source: https://www.helius.dev/preconfirmations.md_ > Stream Solana transactions the instant a validator's scheduler commits to executing them. This is the earliest signal Helius offers. **Preconfirmations** ## Stream scheduled Solana transactions Preconfirmations stream transactions the instant a validator's scheduler commits to executing them — earlier than shred delivery and confirmed-commitment streams. [Get started](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/pre-confirmations/overview) **PRECONFIRMATIONS (PRECONFS)** ## A filtered firehose, built for the fast path Open a single preconfSubscribe WebSocket and stream scheduled transactions as compact binary frames, a fixed 18-byte header your decoder reads in nanoseconds. - Server-side filters: accounts, regions, failed txs - Only receive and pay for the flow you trade on - Compact binary frames: no JSON parsing on the hot path - Pair with Sender Max to land first on what you see first [Start building](https://dashboard.helius.dev/signup) [View docs](https://www.helius.dev/docs/pre-confirmations/overview) - **Lifecycle stage**: Scheduled txn - **Transport**: WebSocket - **Faster than Shreds**: 5-50 ms ## Subscribe once, react first - **Open a subscription**: Connect to the Helius Gatekeeper endpoint and send a single `preconfSubscribe` request. Filter by account, region, or status. Only stream what you care about. - **Get the earliest signal**: Notifications arrive as compact binary frames with the slot, transaction index, status, and full transaction as soon as the scheduler commits to executing them. - **Pay per message**: Slots with zero delivered messages cost zero credits. When a slot delivers at least one message, each subscription is billed the greater of 300 credits or 10 credits per delivered message. ### preconfSubscribe ```json { "jsonrpc": "2.0", "id": 1, "method": "preconfSubscribe", "params": [ { "failed": false, "regionInclude": ["ewr", "fra"], "accountInclude": ["TARGET_WALLET_ADDRESS"], "accountExclude": ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"], "accountRequired": ["11111111111111111111111111111111"] } ] } ``` ## Who are preconfs for? - **Prop AMMs & HFTs**: React to onchain activity at the earliest possible moment to stay ahead of the book - **Snipers**: See new launches the instant they're scheduled, not after they're confirmed - **Copy traders**: Mirror a target wallet's trades the moment their transaction is scheduled - **Liquidation bots**: Detect liquidation opportunities faster than your competitors - **Searchers**: Use preconfs to act on order flow your competitors can't see ## Frequently Asked Questions ### What are Preconfirmations (Preconfs)? Preconfirmations (Preconfs) stream transactions at the earliest point they can be observed: the moment a validator schedules them, before they are collected into entries and converted into shreds. This is the lowest-latency transaction signal Helius offers. ### Are there gaps in Preconfirmation coverage? Yes, there are gaps in coverage. Preconfirmations are only available for transactions scheduled by validators that forward their stream to Helius. Coverage scales with the share of network stake currently sending to Helius, so the stream is not continuous. Your trading system should [account for gaps in coverage](/docs/pre-confirmations/overview#coverage). ### What's the difference between Preconfs and Preprocessed Transactions? Preconfirmations are streamed the moment a validator's scheduler commits to executing a transaction, before any block data leaves the leader. [Preprocessed Transactions](/preprocessed-transactions) come one stage later: once the block has been shredded and propagated. Helius decodes the raw shreds and streams the signed transactions to you over WebSocket, up to 8ms before the `processed` commitment level. Preconfirmations and Preprocessed Transactions are available on all paid plans. See pricing for more details. ### I am a validator. Will Helius pay me for my preconfirmations? Yes. If you operate a Solana validator, you can earn more revenue by forwarding your preconfirmations to Helius. For more information, read [our docs](/docs/pre-confirmations/for-validators). To get started, complete our validator monetization [form](https://form.typeform.com/to/Y8Xx60Yd). ### How much do Helius Preconfirmations cost? Helius Preconfirmations are available on all paid plans (Developer, Business, Professional, and Enterprise). Slots with zero delivered messages cost zero credits. When a slot delivers at least one message, each open `preconfSubscribe` subscription is billed the greater of 300 credits or 10 credits per delivered message. See [Credits](/docs/billing/credits) for details. ### How can I get started with Preconfirmations? To get started, explore these resources: - [Preconfirmations Documentation Overview](/docs/pre-confirmations/overview) - [preconfSubscribe Guide](/docs/pre-confirmations/preconf-subscribe) - [preconfSubscribe API Reference](/docs/api-reference/pre-confirmations/preconfsubscribe) - [preconfUnsubscribe API Reference](/docs/api-reference/pre-confirmations/preconfunsubscribe) - [getPreConfCoverage API Reference](/docs/api-reference/pre-confirmations/getpreconfcoverage) ## Get the earliest signal on Solana Subscribe to preconfs and react the moment txs are scheduled. Available on all paid plans. [Start building](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/pre-confirmations/overview) --- ## Preprocessed Transactions: Pre-execution Solana Data _Source: https://www.helius.dev/preprocessed-transactions.md_ > Stream signed Solana transactions before `processed`. We decode the shreds; you get a filtered WebSocket. 0.1 credits/message. All paid plans. **Preprocessed Transactions** ## Pre-execution Solana data Receive decoded Solana transactions up to 8ms faster than regular processed transaction streams. [Start building](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/preprocessed-transactions/overview) ## How it works - **Define your filters**: Determine which accounts you want to include, exclude, and make required. Supports up to 5,000 addresses per list and auto-resolves Address Lookup Tables. - **Open a subscription**: Send a single `preprocessedSubscribe` request with your filters. Notifications arrive as compact binary frames with the slot, signature, and full transaction. - **Deduplicate and land**: Dedupe by signature, treat the slot as an observation, and reconcile against a processed stream when results matter. Pair with Sender to act on what you see. ## Who are Preprocessed Transactions for? - **DEX aggregators**: Refresh routes and quotes from decoded, pre-execution flow without running infra - **Trading terminals**: Give your traders buy, sell, and graduation data in their trading terminal faster - **Launchpads**: Show new pools, buys, and migrations in your UI as soon as they're decoded - **Copy traders**: Mirror a target wallet's trade the moment its transaction is decoded from raw shreds - **DeFi applications**: See incoming program interactions as signed transactions before they're processed - **Telegram trading bots**: Stream decoded transactions for watched programs without standing up shred infra ## See it, bid it, land it with Sender Max Once you receive Preprocessed Transactions, use Helius Sender to reliably land time-sensitive trades onchain. [Learn more](https://www.helius.dev/sender) ## Early onchain signals, decoded for you We decode shreds as they arrive at our validator and stream transactions via WSS as binary frames: version, slot, signature, and serialized transaction. - 8ms faster than the `processed` commitment level - No raw UDP packets or deshredding infra required - Payload includes full signed transactions: version, signature, accounts, instructions, and slot [View docs](https://www.helius.dev/docs/preprocessed-transactions/overview) **See also:** - [Raw Shred Delivery](https://www.helius.dev/shreds): Stream raw shreds and decode them yourself ## Only receive and pay for the data you need Every subscription is scoped by account. Filtering happens server-side, so you never ingest a full firehose to find the transactions that matter. - Filter by `accountInclude`, `accountExclude`, and `accountRequired` combined with `AND` logic - Supports up to 5,000 addresses per list and automatically resolves Address Lookup Tables (ALTs) - 0.1 credits per message, available on all paid plans [View docs](https://www.helius.dev/docs/preprocessed-transactions/preprocessed-subscribe#filtering) ## Frequently Asked Questions ### On what plans are Preprocessed Transactions available? Preprocessed Transactions are in public beta and are available on all [paid plans](/pricing). ### How many credits do Preprocessed Transactions cost? Preprocessed Transactions cost 0.1 [credits](/docs/billing/credits#preprocessed-transactions) per message. One message is equal to one delivered transaction. ### Will LaserStream Preprocessed (gRPC) be deprecated? Yes, LaserStream Preprocessed (gRPC) will be deprecated in favor of Preprocessed Transactions over WebSockets. If you're using LaserStream Preprocessed, please migrate. ### What's the difference between Preprocessed Transactions and processed? Preprocessed Transactions are pre-execution data that is available before the transaction is processed by the rest of the network, and are strictly faster than the `processed` [commitment level](/blog/solana-commitment-levels). To stream `processed` transactions, use [LaserStream gRPC](/docs/laserstream) or [LaserStream WebSockets](/docs/rpc/websocket). ### What's the difference between Preprocessed Transactions and Preconfs? A preconfirmation means a validator's scheduler has committed to executing the transaction, but it has not yet landed onchain. [Preconfirmations](/preconfirmations) occur before transactions are propagated across the network as raw shreds. Preprocessed Transactions are raw shreds that have been decoded for you. ### What's the difference between Preprocessed Transactions and Shred Delivery? Preprocessed Transactions are raw shreds that are decoded for you and served over WebSockets. [Helius Shred Delivery](/shreds) streams raw shreds over UDP, and consumers are responsible for deshredding the packets on their own. ### How can I get started with Preprocessed Transactions? To get started, explore these resources: - [Preprocessed Transactions Documentation Overview](/docs/preprocessed-transactions/overview) - [preprocessedSubscribe Guide](/docs/preprocessed-transactions/preprocessed-subscribe) ## Get started Available on all paid plans at 0.1 credits per message. No deshredder required. [Start building](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/preprocessed-transactions/overview) --- ## Helius Pricing: Solana RPCs and APIs _Source: https://www.helius.dev/pricing.md_ > Flexible pricing to suit all your Solana development needs: affordable shared plans, dedicated nodes, node fleets, staked connections, and more. ## Simple pricing for teams of any scale ## Compare plans ### Free - $0/month *Ideal for testing* - 1M credits - 10 Requests / sec - 1 sendTransaction / sec - ~~sendBundle~~ (not included) - ~~Staked Connections~~ (not included) - LaserStream WSS (standard) - ~~LaserStream gRPC~~ (not included) - ~~Preprocessed Transactions~~ (not included) - ~~Shreds - $1,000/month/IP~~ (not included) - Community support [Get started](https://dashboard.helius.dev/signup?plan=free) ### Developer - $49/month *For small projects* - 10M credits - 50 Requests / sec - 5 sendTransaction / sec - ~~sendBundle~~ (not included) - Staked Connections - LaserStream WSS - LaserStream gRPC (devnet) - Preprocessed Transactions - Shreds - $1,000/month/IP - Chat support [Get started](https://dashboard.helius.dev/signup?plan=developer) ### Business - $499/month *For growing teams* - 100M credits - 200 Requests / sec - 50 sendTransaction / sec - 5 sendBundle / sec - Staked Connections - LaserStream WSS & gRPC - Preprocessed Transactions - Shreds - $1,000/month/IP - Priority chat support [Get started](https://dashboard.helius.dev/signup?plan=business) ### Professional - $999/month *For teams at scale* - 200M credits - 500 Requests / sec - 100 sendTransaction / sec - 5 sendBundle / sec - Staked Connections - LaserStream WSS & gRPC - LaserStream Data Add-ons - Preprocessed Transactions - Shreds - $800/month/IP - Telegram + Slack support [Get started](https://dashboard.helius.dev/signup?plan=professional) ## Dedicated Solutions ### LaserStream *For reliable, low-latency streaming data* **Included with Business plans and higher ($499/mon)** - Drop-in replacement for Geyser gRPC - Globally distributed, regional redundancy - Data add-ons start at $400/mon [Learn more](https://www.helius.dev/docs/laserstream) ### Sender *For the fastest transaction landing rates* **Included with all plans** - Routes across every high-speed pathway - 7 regional endpoints for global coverage - 50 TPS (default) [Learn more](https://www.helius.dev/docs/sending-transactions/sender) ### Dedicated nodes *For custom requirements & advanced teams* **Starting from $2,900/mon** - Stream real-time data using gRPC - Simulate Jito bundles - Colocate for a trading edge [Learn more](https://www.helius.dev/docs/dedicated-nodes/getting-started) ## Outperform the Market Get high-performance, SOC 2-compliant infra. For traders, we recommend [Preconfs](https://www.helius.dev/preconfirmations) plus Shred Delivery for low latency trading feeds, and [Sender Max](https://www.helius.dev/sender) for the best landing rates. ## Transparent. Flexible. Risk-free. - **Try before you commit**: Test-drive our developer platform for free. When your project demands more, our paid plans scale with you. - **Autoscaling on your terms**: Control costs with precision. Set your autoscaling limits, track real-time usage, and use alerts to stay within budget. - **Pay how you want**: Pay with crypto or credit card. Subscribe monthly, get 2 months off with annual plans and save more on Enterprise. ## Detailed Plan Comparison ### Free - **Price**: $0/month - **Credits**: 1M/month - **Additional credits**: -/million - **RPC requests**: 10/sec - **Additional RPC RPS**: - - **DAS requests**: 2/sec - **sendTransaction**: 1/sec - **sendBundle**: Not available - **getProgramAccounts**: 5/sec - **Staked Connections**: No - **Archival Data**: Yes - **Webhooks**: Yes - **LaserStream WSS (standard)**: Yes - **transactionSubscribe**: No - **LaserStream gRPC**: No - **LaserStream Data Add-ons**: No - **Preprocessed Transactions**: No - **Raw Shreds price per month / IP**: $1,000 - **Support SLA**: - - **Chat Support**: No - **Dedicated Slack + Telegram**: No ### Developer - **Price**: $49/month - **Credits**: 10M/month - **Additional credits**: $5/million - **RPC requests**: 50/sec - **Additional RPC RPS**: - - **DAS requests**: 10/sec - **sendTransaction**: 5/sec - **sendBundle**: Not available - **getProgramAccounts**: 25/sec - **Staked Connections**: Yes - **Archival Data**: Yes - **Webhooks**: Yes - **LaserStream WSS (standard)**: Yes - **transactionSubscribe**: Yes - **LaserStream gRPC**: Devnet - **LaserStream Data Add-ons**: No - **Preprocessed Transactions**: 0.1 credits/msg - **Raw Shreds price per month / IP**: $1,000 - **Support SLA**: 24 hours - **Chat Support**: Yes - **Dedicated Slack + Telegram**: No ### Business - **Price**: $499/month - **Credits**: 100M/month - **Additional credits**: $5/million - **RPC requests**: 200/sec - **Additional RPC RPS**: - - **DAS requests**: 50/sec - **sendTransaction**: 50/sec - **sendBundle**: 5/sec - **getProgramAccounts**: 50/sec - **Staked Connections**: Yes - **Archival Data**: Yes - **Webhooks**: Yes - **LaserStream WSS (standard)**: Yes - **transactionSubscribe**: Yes - **LaserStream gRPC**: Yes - **LaserStream Data Add-ons**: No - **Preprocessed Transactions**: 0.1 credits/msg - **Raw Shreds price per month / IP**: $1,000 - **Support SLA**: 12 hours - **Chat Support**: Yes - **Dedicated Slack + Telegram**: No ### Professional - **Price**: $999/month - **Credits**: 200M/month - **Additional credits**: $5/million - **RPC requests**: 500/sec - **Additional RPC RPS**: $100 - **DAS requests**: 100/sec - **sendTransaction**: 100/sec - **sendBundle**: 5/sec - **getProgramAccounts**: 75/sec - **Staked Connections**: Yes - **Archival Data**: Yes - **Webhooks**: Yes - **LaserStream WSS (standard)**: Yes - **transactionSubscribe**: Yes - **LaserStream gRPC**: Yes - **LaserStream Data Add-ons**: Starting at $400/month - **Preprocessed Transactions**: 0.1 credits/msg - **Raw Shreds price per month / IP**: $800 - **Support SLA**: 8 hours - **Chat Support**: Yes - **Dedicated Slack + Telegram**: Yes ### Enterprise - **Price**: Custom/month - **Credits**: 1B+/month - **Additional credits**: Custom/million - **RPC requests**: Custom/sec - **Additional RPC RPS**: Custom - **DAS requests**: Custom/sec - **sendTransaction**: Custom/sec - **sendBundle**: 5/sec - **getProgramAccounts**: Custom/sec - **Staked Connections**: Yes - **Archival Data**: Yes - **Webhooks**: Yes - **LaserStream WSS (standard)**: Yes - **transactionSubscribe**: Yes - **LaserStream gRPC**: Custom - **LaserStream Data Add-ons**: Custom - **Preprocessed Transactions**: 0.1 credits/msg - **Raw Shreds price per month / IP**: Custom - **Support SLA**: 4 hours - **Chat Support**: Yes - **Dedicated Slack + Telegram**: Yes ## Helius vs. other RPC providers Compare [Solana RPC provider benchmarks](https://www.helius.dev/benchmarks) across methods and regions. ### Helius - **Dedicated RPC Nodes**: Yes - **Solana Domain Expertise**: Yes - **Indexing Support for All Tokens**: Yes - **Transaction Parsing API**: Yes - **Webhook Support**: Yes - **Wallet Signup & Crypto Subscriptions**: Yes - **RPC Rate Limit**: 500 RPS - **Uptime**: 99.99% - **Support SLA**: 8 hours ### Quicknode - **Dedicated RPC Nodes**: No - **Solana Domain Expertise**: No - **Indexing Support for All Tokens**: No - **Transaction Parsing API**: No - **Webhook Support**: No - **Wallet Signup & Crypto Subscriptions**: No - **RPC Rate Limit**: 500 RPS - **Uptime**: 99.84% - **Support SLA**: 8 hours ### Alchemy - **Dedicated RPC Nodes**: No - **Solana Domain Expertise**: No - **Indexing Support for All Tokens**: No - **Transaction Parsing API**: No - **Webhook Support**: No - **Wallet Signup & Crypto Subscriptions**: No - **RPC Rate Limit**: 120 RPS - **Uptime**: 99.85% - **Support SLA**: 12 hours ## Trusted by Solana's best teams > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana. They power a great portion of our infrastructure at Backpack." — **Armani Ferrante**, CO-FOUNDER & CEO, BACKPACK > "The Helius team makes building on Solana smoother and easier. They've done an amazing job at streamlining and removing complexity from app development on the network." — **Anatoly Yakovenko**, CO-FOUNDER & CEO, SOLANA > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM > "The Helius team is the GOAT. They ship fast, intake product feedback overnight, and power a great deal of Crossmint infrastructure. A big percentage of Crossmint products couldn't exist without Helius." — **Alfonso Gomez Manas**, CO-FOUNDER, CROSSMINT > "Having personally built our own in-house indexing and data pipelines at Zeta, I know how much of a headache it is for new teams. Being able to save countless hours of data engineering work and costly AWS bills is a big advantage for us." — **Tristan Frizza**, FOUNDER & CEO, ZETA MARKETS > "Helius has been instrumental in kickstarting our Pythnet operations. Their seamless infrastructure management ensures everything runs smoothly, allowing us to focus on building and scaling our trading operations without worrying about the details of running Solana nodes." — **Jeremy De Groodt**, CO-FOUNDER & CTO, KEYROCK > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." — **Jonathan Levin**, CEO AND CO-FOUNDER, CHAINALYSIS > "We tried every strategy to land transactions on Solana, but nothing was working. The moment we switched our RPCs to Helius and started sending transactions through staked connections, all of our problems disappeared. Now we can confidently scale our business on Solana without worrying about our customer's transactions getting dropped." — **Cody Lambert**, SOFTWARE ENGINEER, BRALE > "When it comes to SOL staking, Helius is truly differentiated. Helius is the industry leader when it comes to running secure, reliable, and performant validators. Since launching in 2022, they have championed Solana's success, built world-class infrastructure, and stewarded the network to become what it is today - the foundation on which the new financial system will be built." — **Cosmo Jiang**, GENERAL PARTNER AT PANTERA CAPITAL AND BOARD OBSERVER AT HSDT > "We're thrilled to partner with Helius in building our own Solana validator for the Bitwise Solana Staking ETF. Not only is Helius the standard bearer for Solana validators when it comes to areas like performance, reliability, and security, but their native understanding of Solana and its ecosystem is unmatched. They've helped us build the perfect high performance validator—one that meets our stringent needs around security and reporting as an ETF issuer." — **Hong Kim**, CTO, BITWISE ASSET MANAGEMENT > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." — **Nitesh Nath**, CEO, DFLOW ## Frequently Asked Questions ### What are credits? [Credits](https://www.helius.dev/docs/billing/credits) vary by usage. RPC calls are 1 credit with a few exceptions: getProgramAccounts and getTransfersByAddress cost 10 credits; getTransactionsForAddress costs 10 credits per 100 full transactions returned, rounded up, with a 10-credit minimum; signatures-only responses cost 10 credits flat. DAS calls are 10 credits. Webhook pushes are 1 credit. Priority Fee API calls are 1 credit. If you're currently using the Enhanced Transactions API, migrate to the [Parsed Events API](https://www.helius.dev/parsed-data). Parsed Events are available on all plans and cost 10 credits per request. Parsed Streams cost 1 credit/event. ### What are data add-ons? Data add-ons for LaserStream and Enhanced WebSockets give you access to flexible, scalable data streaming bandwidth at a predictable, fixed monthly rate. [Add-on plans](https://www.helius.dev/docs/billing/plans#data-add-ons) are available on the Professional tier only, and are priced as follows: 5TB ($400/mon), 10TB ($750/mon), 25TB ($1,750/mon), 50TB ($3,250/mon), and 100TB ($6,000/mon). For larger data add-ons and volume-based pricing, please [contact sales](https://form.typeform.com/to/KiacmxpZ). ### What plan is right for me? Developer gives you the core functionality to get started - great for small projects. Business offers more usage and throughput - perfect for mid-size projects. Professional supports even more usage and throughput - ideal for teams operating at scale. ### How do I upgrade/downgrade my plan? Login to the [dashboard](https://dashboard.helius.dev/dashboard), click on the link to Manage My Subscription, and select your desired option. ### What is your cancellation policy? Plans are billed month-to-month, meaning you can cancel at any time. Cancellations will become effective the following month, and your service will continue until the end of your current month. ### I have more questions, who can I ask? For [more FAQs](https://www.helius.dev/docs/faqs), visit the support section in our docs.For technical support questions please join our [Discord](https://discord.com/invite/6GXdee3gBj) server, [Telegram](https://t.me/helius_help) group, or if you have a paid plan, use the chat feature in the [dashboard](https://dev.helius.xyz/dashboard/app).‍For sales and pricing questions, email [sales@helius.xyz.](mailto:sales@helius.xyz) ## Ready to build? Get started in less than 10 seconds. No credit cards or email required. [Start building](https://dashboard.helius.dev/) --- ## Solana Privacy Rings _Source: https://www.helius.dev/privacy.md_ > Transact on Solana without exposing sender, recipient, asset or amount. Self-custodial, configurable, and fully onchain. Live on Solana Mainnet. **Solana Privacy Rings** ## Private Money, Payments, and Finance on Solana Transact on Solana without exposing sender, recipient, asset or amount. Self-custodial, configurable, and fully onchain. Live on Solana Mainnet. [Get started](https://dashboard.helius.dev/privacy-rings-api) | [View docs](https://www.helius.dev/docs/privacy) ## Confidential rails
for global finance - **Institutions**: Payroll, payments, and transfers processed privately onchain with full audit trails. - **Fintech Wallets**: Embed private wallets with a single SDK integration so user history stays encrypted. - **Payment cards**: Spend from private onchain balances so transactions don't leak cardholder history. - **RWA Settlement**: Settle tokenized assets onchain without exposing positions or counterparties. - **Trading & Treasury**: Rebalance and manage liquidity 24/7 without revealing market positions or timing. - **Collateral Management**: Privately move and rehypothecate collateral without telegraphing your exposure or risk. Try it: [Live demo on Solana Devnet](https://www.helius.dev/privacy/demo) ## Fully private transfers Send to any Solana address with Zero Knowledge (ZK) proofs hiding the sender, recipient, asset, and amount. - Supports any asset: works for any Solana asset from stablecoins to tokenized stocks. - Encrypted: data is encrypted onchain. No one can reconstruct your activity without permission. - Works with any Solana address: recipients don't need a special wallet to receive private funds. [Get started](https://dashboard.helius.dev/privacy-rings-api) [View docs](https://www.helius.dev/docs/privacy/guides/transfer) **See also:** - [Confidential Delivery versus Payment](https://www.helius.dev/privacy/demo/dvp): View our private DVP demo on Solana Devnet ## Privacy without surrendering control Helius generates proofs and relays your transactions. We never hold your keys or touch your funds. - Authorize every transaction: private transfers require the owner's signature. - Assets stay on Solana: encrypted balances execute onchain, without an offchain ledger. - Choose who sees what: keep viewing keys local or delegate without granting spend authority. [Get started](https://dashboard.helius.dev/privacy-rings-api) [View docs](https://www.helius.dev/docs/privacy) **See also:** - [Encryption and Privacy Guarantees](https://www.helius.dev/docs/privacy/concepts/encryption): Learn what is public vs. encrypted ## Native to Solana Every private transfer settles directly on Solana. No L2s, new trust assumptions, or extra infrastructure. - Assets never leave Solana: no wrapped tokens, sidechains, or additional bridge risk. - Works with your stack: track transactions with normal Solana signatures and familiar APIs. - Composable: private balances interoperate with Solana DeFi through cross-program invocations. [Get started](https://dashboard.helius.dev/privacy-rings-api) [View docs](https://www.helius.dev/docs/privacy/concepts/overview) **See also:** - [RPC Methods for Solana Privacy Rings](https://www.helius.dev/docs/api-reference/privacy): Get shielded transactions, encrypted outputs, and more ## Your rules, enforced onchain Configure privacy rings with the policy and compliance controls you need. - Configurable: set the rules for your policies - Non-custodial: ring authorities don't hold funds - Interoperable: seamlessly move between privacy rings and the public Solana network [Contact us](https://www.helius.dev/contact) | [View docs](https://www.helius.dev/docs/privacy/integration/enterprise) ## Frequently Asked Questions ### What are Solana Privacy Rings? [Solana Privacy Rings](https://www.helius.dev/docs/privacy/concepts/overview#solana-privacy-rings) are programmable shielded pools with encrypted onchain balances and execution directly on Solana. ### Is Solana Privacy Rings self-custodial? Yes. To learn more, read our [docs](/docs/privacy) and [core concepts](/docs/privacy/concepts). ### What stays private in a transfer? By default, transfers are confidential and encrypt the asset and amount, while the sender and recipient stay public. For full anonymity that also encrypts the sender and recipient, you can configure a custom anonymous ring. To learn more, read our [docs on private transfers](/docs/privacy/guides/transfer). ### Do I need a special address to send privately? No. You always enter a normal Solana address. The Privacy API routes the transfer automatically: privately if the recipient has a Private Wallet, otherwise as a withdrawal to their public address. To learn more, read our [docs on private transfers](/docs/privacy/guides/transfer). ### What happens if I send to someone who doesn't have a private wallet? The transfer becomes a private-to-public withdrawal and the Privacy API routes the transfer automatically. The recipient receives the funds at their normal Solana address. ### What's visible when I deposit to a private balance? The source token account, asset, and amount are public, because the funds move from a normal Solana wallet. The resulting private balance is hidden. To learn more, read our [docs on private deposits](/docs/privacy/guides/deposit). ### What's visible when I withdraw from a private balance? Withdraw moves tokens from a private to a public Solana balance. The asset, amount, and resulting public balance are public. In a confidential ring the source is public, and in an anonymous ring it is private. To learn more, read our [docs on private withdrawals](/docs/privacy/guides/withdraw). ### Can I onramp USD, EUR, or currencies directly into a private balance? Yes. To see on and off-ramps in action, view this [privacy demo](https://helius-privacy-demo.fly.dev/). To learn more, read our [docs on integrating On/Off-ramps](/docs/privacy/integration/on-off-ramp). ### Who can see my private balances? Only the user and a view-only auditor in custom privacy rings. To learn more, read our docs on [reading private balances](/docs/privacy/guides/read-balance) and [custom privacy rings](/docs/privacy/integration/enterprise). ### What are Custom Rings? Custom Rings make privacy on Solana programmable. You will be able to [configure a privacy ring](/docs/privacy/integration/enterprise) to be confidential (encrypted asset, amount), or fully anonymous (encrypted sender, recipient, asset, amount) with custom policy and compliance controls to enforce rules such as: Allowed assets, for example only USDC or a specific stablecoin. Transfer limits that require extra approval above a threshold. Allowlists and blocklists for approved or sanctioned destinations. Auditor visibility for compliance, accounting, or regulators. Freeze and thaw to hold a balance during an investigation. You can bring your own compliance, or use Helius' managed KYC and sanction screening. ### Do I need to bring my own compliance for my Custom Ring? You can bring your own compliance, or use Helius' managed KYC and sanction screening. To learn more, read our [docs on Custom Rings](/docs/privacy/integration/enterprise). ### Is Solana Privacy Rings live? Yes, Solana Privacy Rings is live on Solana Mainnet and Devnet. It has been audited by OtterSec, Certora, and ZK Security with formal verification underway. View [endpoints](/docs/privacy/endpoints) and our [SDK](/docs/privacy/sdk) to get started. ### How can I get started with Solana Privacy Rings? To get started, explore these resources: - [Solana Privacy Rings Overview](/docs/privacy) - [Privacy Concepts](/docs/privacy/concepts) - [Private Deposit Guide](/docs/privacy/guides/deposit) - [Private Transfer Guide](/docs/privacy/guides/transfer) - [Privacy SDKs](/docs/privacy/sdk) - [Privacy API References](/docs/api-reference/privacy) Can't find what you're looking for? Reach out to our support team and we'll be happy to help. [Contact us](https://www.helius.dev/contact) ## Go private Bring programmatic, onchain privacy to your app today [Contact us](https://www.helius.dev/contact) | [Get started](https://dashboard.helius.dev/privacy-rings-api) --- ## Solana Transaction Rebates: Earn SOL on Eligible Trades _Source: https://www.helius.dev/rebates.md_ > Automatically earn SOL back on every eligible trade through Helius Transaction Rebates with no change to how you build or send transactions. **Transaction Rebates** ## Earn SOL back on every eligible trade Your transactions create valuable backrun opportunities. Transaction Rebates capture that value and pay it back to you in SOL — automatically, with no change to how you build or send transactions. [Start earning](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/sending-transactions/backrun-rebates) **EARN** ## Generate revenue from flow you already send Capture valuable arbitrage opportunities created from your flow, with no additional MEV risk, instead of leaking that value to searchers. - Send transactions as usual: build and send transactions exactly how you do today — no code changes required - We capture backrun value: when your transaction creates a profitable backrun, that value is captured on your behalf - You earn SOL rebates: a share of the captured value is rebated back to you in SOL — automatically [Start earning](https://dashboard.helius.dev/signup) [View docs](https://www.helius.dev/docs/sending-transactions/backrun-rebates) - **Rebates paid in**: SOL - **Integration effort**: Zero - **Extra API credits**: 0 ## Who earns with rebates? - **High frequency traders**: Recapture value from the arbitrages your flow creates and improve net execution costs. - **DeFi applications**: Turn your users' swap flow into an additional revenue stream, at no cost to them. - **Wallets**: Earn SOL on the transactions you already broadcast, with zero integration work. - **Telegram trading bots**: Add a margin on every trade your users route through you, automatically. - **Trading frontends**: Earn SOL on retail trading flows, with no additional MEV risk. - **Aggregators and routers**: Capture the arbs your routed swaps create, on top of the fees you already charge. ## Frequently Asked Questions ### What are transaction rebates? Helius Transaction Rebates let you earn a share of the MEV (Maximum Extractable Value) your transactions create. When your trade generates profitable arbitrage opportunities you get paid a portion of the profits in SOL. ### What is backrunning? Backrunning is a beneficial form of arbitrage that helps keep prices consistent across different exchanges. Unlike malicious MEV attacks, backrunning improves the network by correcting price imbalances created by large trades. For example, when you buy $BONK on Raydium, the price goes up on that exchange, but stays the same on Orca. A searcher then buys $BONK on Orca where the price is cheaper, and sells $BONK on Raydium where the price is higher, capturing the difference as profit. With Helius Transaction Rebates, applications earn a percentage of this profit from the trades that originated in their app. ### Are transaction rebates safe? Yes. Your transaction executes first in bundles with pre-approved searchers who can only perform post-trade backruns. Unlike other validators who could engage in malicious forms of MEV, Helius only permits post-trade backruns - no frontrunning is allowed. For complete transparency, all bundle activity is visible and verifiable onchain. ### Are transaction rebates optional? Yes, transaction rebates are an optional feature. Helius will never participate in backrun rebates without your explicit permission. You must opt in by adding the rebate-address parameter to your transaction requests. ### How and when do I get paid? Transaction Rebates are paid automatically in SOL in the same block as your transaction. ### How much revenue do I earn? You earn 50% of the MEV that your transaction creates. [Contact us](https://www.helius.dev/contact) if you have high volume to discuss custom terms. ### How can I get started with Transaction Rebates? To get started, explore these resources: - [Transaction Rebates Guide](/docs/sending-transactions/backrun-rebates) ## Start earning SOL rebates Rebates are pure upside. Turn on Helius transaction sending and earn from flow you already send. [Start earning](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/sending-transactions/backrun-rebates) --- ## Helius Sender: Land Solana Transactions Faster _Source: https://www.helius.dev/sender.md_ > Send Solana transactions across every high-speed pathway to reliably land on-chain. 7 global endpoints. 0 credits. Built for speed. **Sender** ## Your edge to landing Solana transactions Send Solana transactions across every high-speed pathway to reliably land on-chain. 7 global endpoints. 0 credits. Built for speed. [Start Sending](https://www.helius.dev/docs/sending-transactions/sender) **WIN MORE** ## Land Solana transactions, everywhere, every time Maximize your transaction inclusion probability. Sender routes every transaction across all available high-speed pathways and enters it into a priority tip buffer — tip more to improve your chances of landing first. - 50 TPS (default) — available on every plan - No API credits — pay per send with a SOL tip - Sender Max from 0.001 SOL; SWQOS-only from 0.000005 [Start Sending](https://www.helius.dev/docs/sending-transactions/sender) [Get custom plans](https://www.helius.dev/contact) - **Regions covered**: 7 - **Minimum SOL tip**: 0.000005 - **API Credits**: 0 ## Easy to set up, tough to beat - **Built for speed**: Every transaction is routed across all available high-speed pathways and entered into a priority tip buffer with optimized networking and geographical routing — tip more to land first. - **Distributed globally**: 7 geographic locations including Tokyo, Singapore, London, Amsterdam, Frankfurt, Salt Lake City and Newark. - **Backed by Solana's largest validator**: Never worry about staked bandwidth. Send transactions through Solana's #1 staked validator. ### Send Transaction ```json { "id": "1", "jsonrpc": "2.0", "method": "sendTransaction", "params": [ // Only the Sender tip is required; a priority fee is recommended "BASE64_ENCODED_TRANSACTION", { "encoding": "base64", "skipPreflight": true, // Optional — skipping just lowers latency "maxRetries": 0 } ] } ``` ## Who is Sender for? - **Memecoin sniper bots**: Increase your chances of sniping newly launched memecoins - **Telegram trading bots**: Land transactions more predictably and estimate fees more accurately - **Wallets**: Give users a better swapping experience with higher landing rates. - **DeFi applications**: Land user's transactions even during periods of network congestion. ## Need higher TPS or custom plans? Our ultra-low latency transaction service offers custom TPS limits and tip arrangements tailored to your trading needs. Contact us for details. [Contact us](https://www.helius.dev/contact) ## Trusted by Solana's best > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM, Phantom ## Frequently Asked Questions ### What is Sender? Sender is a Solana transaction submission service optimized for ultra-low latency. As one unified service, Sender routes your transaction across every high-speed pathway, giving propAMMs, copy trader, snipers, and arb bots top of block landing in all network conditions. Sender uses no credits — you pay only through the SOL tip. ### Is Sender available on all Helius plans? Yes, Sender is available on all Helius plans. From the Helius dashboard, get a [Sender endpoint URL](https://dashboard.helius.dev/sender) to [start sending transactions](/docs/sending-transactions/sender). ### Where are Sender endpoints located? Sender endpoints are distributed across 7 regions: Salt Lake City, Newark, London, Frankfurt, Amsterdam, Singapore, and Tokyo. For best results, choose the Sender endpoint that is closest to where your application is hosted. ### How many Helius credits does Sender cost? Sending Solana transactions through Sender does not consume API credits from your plan. ### How many transactions per second can I send through Sender? Sender’s default rate limit is 50 transactions per second or TPS. If you require higher rate limits, please [contact us](https://www.helius.dev/contact) and we will follow up with next steps. ### What is the minimum tip required for sending Solana transactions with Sender? Sender has two tiers. Sender Max is the flagship option for the fastest landing: it requires a minimum tip of 0.001 SOL, routes your transaction across every high-speed pathway, and enters it into a priority auction where tipping more helps you land first. Sender Max handles both transactions and bundles. SWQOS-only is the cost-optimized option: it uses a single fast path, requires a minimum tip of just 0.000005 SOL (5,000 lamports), and is enabled by adding ?swqos_only=true to your Sender endpoint URL. Tips between 0.000005 and 0.001 SOL are accepted on a best-effort basis and do not enter the priority auction. Sender uses no credits — you pay only through the SOL tip. ### Does Sender require a tip, and are priority fees needed? Only the tip is strictly required, and it is paid in SOL — Sender uses no credits. A priority fee is recommended but not required, and skipPreflight is optional. Sender submits your transaction through one unified service across every high-speed pathway to maximize the probability that it lands. Increase the tip close to the value of the transaction to maximize inclusion at top of block. ### How do I route transactions only through Helius SWQoS? Add ?swqos_only=true to your Sender endpoint URL to use the SWQOS-only tier. This routes your transaction through a single fast path and requires a lower minimum tip of 0.000005 SOL (5,000 lamports). For the fastest landing across every high-speed pathway with a priority auction, use Sender Max instead (0.001 SOL minimum tip). ### What transaction data feeds should I pair with Sender? For the earliest onchain data, pair Sender with [Preconfirmations](/preconfirmations) so you can trade on scheduled transactions before they land onchain. The next fastest feeds are [Raw Shreds](/shreds) if you can decode UDP packets yourself, or [Preprocessed Transactions](/preprocessed-transactions) if you want those same shreds decoded for you and streamed over WebSocket. LaserStream provides `processed`, `confirmed`, and `finalized` data with full execution metadata. ### Is it better to use Sender or staked connections for landing transactions? TL;DR — if your team cares about speed and ultra-low-latency transaction landing rates (e.g., most trading use cases), then you should use Sender. Sender routes transactions across every high-speed pathway in parallel as one unified service. If speed is not as critical for your use case, then using [Staked Connections](https://www.helius.dev/staked-connections), which are included by default in all Helius [shared plans](/docs/billing/plans), is likely better for you. ### How can I get started with Sender? To get started, explore these resources: - [Sender Documentation Overview](/docs/sending-transactions/sender) - [Sender Max Guide](/docs/sending-transactions/sender-max) - [Sender API Reference](/docs/api-reference/sender/sendtransaction) - [Stake-Weighted Quality of Service Guide](/docs/sending-transactions/sender-swqos-only) ## Tired of losing trades? Use Sender to accelerate your Solana transactions and compete for every trade. Available on all plans. [Start Sending](https://www.helius.dev/docs/sending-transactions/sender-max) --- ## Helius Shred Delivery _Source: https://www.helius.dev/shreds.md_ > Turn milliseconds into PnL. Get the earliest possible access to Solana’s raw, unprocessed transaction data with Helius Shred Delivery. **Shred Delivery** ## Turn milliseconds into PnL Helius Shred Delivery is a premier, low-latency shred delivery service, built to give you the earliest possible access to Solana’s raw, unprocessed transaction data. [Get started](https://dashboard.helius.dev/shred-delivery-seats) | [View docs](https://www.helius.dev/docs/shred-delivery) **TRADE WITH CONFIDENCE** ## Trade smarter. Trade faster. Turn speed into alpha. Helius Shred Delivery is built for latency-sensitive strategies, giving you an asymmetric advantage when it matters most. - Real-time, raw shreds - Direct data feeds to your server - Reliable, high availability uptime [Get started](https://dashboard.helius.dev/shred-delivery-seats) [View docs](https://www.helius.dev/docs/shred-delivery/raw-shreds) ## Who is Shred Delivery for? - **HFT Desks**: Detect onchain transaction events first to increase your edge and submit profitable trades before other trading desks. - **MEV Searchers**: Maximize your profits by getting a first look at new onchain trades, and capitalizing on information asymmetry. - **Memecoin Snipers**: Increase your transaction inclusion probability by being the first to see and execute trades on newly launched tokens. - **DEX Aggregators**: Update your routes, quotes, and prices using pre-processed transaction data to offer the most competitive rates. - **Liquidation Engines**: Find liquidation opportunities and submit transactions before your competitor's bots have a chance to react. - **RFQ Desks**: Enhance your quoting accuracy and speed by harnessing a direct feed of Solana's onchain transaction data. ## The fastest way to get onchain transaction data - **Validator Advantage**: Helius is a top validator by stake and receives shreds faster than validators with less stake and non-staked RPC nodes. - **Global Delivery**: Helius Shred Delivery is optimized for ultra low latency regardless of where your server is geographically located or who the leader is. - **Earliest Access**: Get raw shreds delivered directly to your servers as soon as they're produced onchain. Simply provide your IP address and port. ## Frequently Asked Questions ### What regions does Shred Delivery support? Our Shred Delivery system is designed to get you raw shreds fastest anywhere in the world, including common locations like FRA, AMS, TYO, EWR, and more. During setup we validate path quality and ensure we're delivering raw shreds from servers closest to you. ### What are shreds? Solana blocks are divided into small data packets known as shreds. These shreds are approximately 1.2 KB in size and contain Solana transaction data that is propagated across the network before being assembled into a full block. There are two types of shreds: data shreds, which contain the core transaction data from a block, and coding shreds, which provide parity data for redundancy using Reed-Solomon erasure coding. ### How do trading systems consume shreds? To [convert raw Solana shreds into actionable trading signals](https://www.helius.dev/blog/solana-shreds#how-are-shreds-reassembled-into-blocks), shreds are reassembled by first verifying their signatures for authenticity. Next, Reed-Solomon erasure coding is used to reconstruct missing or corrupt data shreds from the coding shreds in the FEC set. Then, the verified, reconstructed shreds are deshredded. Deshredding is the process of concatenating shred payloads in order using shred indices to reform serialized entry batches. These batches are then deserialized into individual transactions and entries. Traders can then compare these entries to Solana’s latest available state to predict which transactions succeed, the resulting account/state changes, and determine if there is a trade to be made. ### When should I use LaserStream vs. Shred Delivery? Both LaserStream and Shred Delivery are fed with low latency shreds. [Shred Delivery](https://www.helius.dev/shreds) is for teams that want raw, unprocessed shreds and can ingest UDP, deshred packets, and parse everything themselves. [LaserStream](/laserstream) is for teams that want processed, confirmed, and finalized on-chain events delivered with ultra-low latency and automatic recovery for backend paths where correctness matters. ### When should I use raw shreds vs. other data streaming tools? Use Shred Delivery when you need the absolute lowest latency access to raw transaction data and have the technical capability to process raw shreds. Use [LaserStream](/docs/laserstream) when you need reliable, processed data with commitment guarantees and historical replay capabilities. If speed is less critical for your application, use [Enhanced Websockets](/docs/rpc/websocket) or standard [Solana WebSockets](/docs/rpc/websocket). If you need a simple, pull-based option, use [webhooks](/docs/webhooks). ### What's the difference between Shred Delivery and Preprocessed Transactions? Shred Delivery streams raw shreds over UDP, and you are responsible for verifying, reconstructing, and deshredding the packets yourself. [Preprocessed Transactions](/preprocessed-transactions) are those same shreds decoded by Helius and streamed to you as signed transactions over WebSocket, up to 8ms before the `processed` commitment level, with account-based server-side filtering and no deshredding infra required. Choose Shred Delivery if you have the capacity to decode raw shreds yourself; choose [Preprocessed Transactions](/docs/preprocessed-transactions/overview) if you want pre-execution data without running a deshredder. ### How do I get access to Helius Shred Delivery? You can[purchase Shreds from your Helius dashboard](https://dashboard.helius.dev/shred-delivery-seats). Simply add a seat and set your IP address and port number to start receiving shreds. For more information, read our [Raw Shreds documentation](/docs/shred-delivery/raw-shreds). ### How can I get started with Shred Delivery? To get started, explore these resources: - [Shred Delivery Documentation Overview](/docs/shred-delivery) - [Raw Shreds Guide](/docs/shred-delivery/raw-shreds) Looking for more technical answers? We've got detailed docs on Shreds. [Documentation](https://www.helius.dev/docs/shred-delivery) ## Get started Purchase raw shreds from your Helius dashboard to start streaming immediately. Simply add a seat and set your IP address. [Get started](https://dashboard.helius.dev/shred-delivery-seats) | [View docs](https://www.helius.dev/docs/shred-delivery/raw-shreds) --- ## Solana RPC Nodes: Get Unmatched Performance _Source: https://www.helius.dev/solana-rpc-nodes.md_ > Give your customers a flawless user experience with ultra-low latency RPCs and industry-leading transaction landing success rates. ## Experience Solana's Best RPC Nodes Unmatched performance, reliability, and Solana expertise with the leading RPC infrastructure. We focus exclusively on Solana to deliver the best RPC experience. [Start for free](https://dashboard.helius.dev/signup) | [Documentation](https://www.helius.dev/docs/rpc/guides/overview) ## Speed and reliability built for scale Leave nothing up to chance. Choose Solana's most battle-tested RPCs and engineering support team that is trusted by 1000s of companies all over the world. ## Up to 10x faster Solana archival RPC methods Query historical Solana data up to 10x faster with our state-of-the-art archival system and exclusive RPC methods like getTransactionsForAddress. [Learn more](https://www.helius.dev/historical-data) ## Are you a trader or enterprise company? Get high-performance, SOC 2-compliant infra. For traders, we recommend LaserStream for gRPC data streams, Sender for the best landing rates, and Shred Delivery for raw transactions. ## RPC nodes for any scale and use case ## Helius vs. other RPC providers Compare [Solana RPC performance benchmarks](https://www.helius.dev/benchmarks) across top JSON-RPC methods and regions for Helius, Alchemy, Quicknode, and Triton. ## Lowest transaction sending latency Land transactions on Solana faster than your competitors with our industry-leading transaction-sending success rates. - **Over99.99%**: Transaction landing rate - **Less than1s**: Confirmation time **See also:** - [Solana RPC Benchmarks](https://www.helius.dev/benchmarks): Compare RPC latency and reliability across providers ## Battle-tested infrastructure With advanced failover systems and redundancy, we guarantee high uptime and have powered Solana's largest events with ease. - **RPC success rate**: 99.99% - **Continents covered**: 3 > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." > — Jonathan Levin, CEO & Co-founder at Chainalysis ## Gatekeeper We built a custom, ultra-low-latency edge gateway to give you the most direct path to our infrastructure, improving response times by tens to hundreds of ms. - Sub-millisecond response times - Tens to hundreds ms faster vs. competitors - Custom indices for faster historical data lookups **See also:** - [Try Gatekeeper (Beta) Today](https://www.helius.dev/docs/gatekeeper/overview): Experience the true speed of Helius RPCs and APIs ## 24/7 expert assistance Solana never sleeps, and neither do we. Whatever challenges you face, our integration engineers are online to unblock your team. - Solana-native engineers - Globally distributed team - 10 min. median support time - Discord, Slack, and Telegram - VIP support channels > "The Helius team has the best customer support. Huma dapp is now working faster and more reliably on Solana." > — Erbil Karaman, Co-founder at Huma Finance ## Trusted by Solana's best > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM, Phantom ## Frequently Asked Questions ### How do Helius's RPC nodes compare to competitors? Compare Helius against [Triton](/compare/triton), [Quicknode](/compare/quicknode), [Alchemy](/compare/alchemy), and other competitors with our open-source [RPC benchmarking tool](/benchmarks). Across multiple different workload types (e.g., trading, general, etc.) Helius is among the highest-scoring, lowest-latency Solana RPC providers on the market. ### How much do Helius's Solana RPC calls cost? Most Solana RPC methods cost 1 credit. `getProgramAccounts` costs 10 credits, and the paginated `getProgramAccountsV2` method costs 1. Historical methods such as `getTransaction` and `getBlock` cost 1 credit. `getTransactionsForAddress` starts at 10 credits and increases with the number of transactions returned. `getTransfersByAddress` costs 10 credits and requires a Developer plan or higher. Monthly allowances are 1 million credits on Free ($0), 10 million on Developer ($49), 100 million on Business ($499), and 200 million on Professional ($999). Usage past the allowance is $5 per million credits. The method table is in the [credits docs](/docs/billing/credits), and plans are on [pricing](/pricing). ### What are Helius's Solana RPC rate limits? RPC rate limits follow your plan: 10 requests per second on Free, 50 on Developer, 200 on Business, and 500 on Professional. Enterprise limits are custom. Professional plans can add 100 requests per second for $100 per month. Some methods have their own caps. For example, `sendTransaction` is 1, 5, 50, or 100 per second from Free through Professional, and `getProgramAccounts` is 5, 25, 50, or 75 per second on those same plans. The full table is in the [rate limits docs](/docs/billing/rate-limits). ### Does Helius RPC include historical Solana data? Yes. Archival methods are included on every plan, including `getTransaction`, `getBlock`, `getSignaturesForAddress`, and custom historical methods like `getTransactionsForAddress` which serves filtered history from a custom index and is up to 10x faster than a standard archival lookup. Details are on the [historical data page](/historical-data). ### What is Gatekeeper? Gatekeeper is the edge gateway in front of Helius's shared RPC infrastructure. Gatekeeper gives requests a shorter path to the node, with sub-millisecond gateway times and tens to hundreds of milliseconds saved versus a typical route. The overview is in the [Gatekeeper docs](/docs/gatekeeper/overview). ### Does Helius offer dedicated RPC nodes? Yes. Dedicated nodes start at $2,900 per month and can be ordered from the dashboard. You choose the region and client. They are not subject to the shared plan's request rate limits. The main reason to run one is Yellowstone gRPC streaming. For most streaming workloads, [LaserStream](/laserstream) is faster and includes historical replay. Use a shared plan for transaction landing, archival queries, and `getProgramAccounts`. Setup steps are in the [dedicated nodes guide](/docs/dedicated-nodes/getting-started). ### How can I get started with Helius's Solana RPCs? To get started, explore these resources: - [Solana RPC Documentation Overview](/docs/rpc/guides/overview) - [Helius Quickstart](/docs/quickstart) - [Solana RPC API Reference](/docs/api-reference/rpc/http-methods) - [getTransactionsForAddress Guide](/docs/rpc/gettransactionsforaddress) - [RPC Optimization Guide](/docs/rpc/optimization-techniques) ## Ready to build? Get started in less than 10 seconds. No credit cards or email required. [Start for free](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/rpc/guides/overview) --- ## Solana Token APIs: Holders, Metadata, and Balances _Source: https://www.helius.dev/solana-token-apis.md_ > Every token. Every transaction. Instantly available. Trusted by Solana's leading wallets and DeFi applications. ## Solana's most powerful Token API Access token metadata for all Solana tokens or check token balances, stats and transaction histories for any token on Solana. [Start for free](https://dashboard.helius.dev/signup) | [Documentation](https://www.helius.dev/docs/das-api) ## Every token. Every transaction. Instantly available. Access high-level token metadata and stats or track token balances and complete history of all transaction and token activities for any account with our Solana token APIs. ## Get all tokens under an account with a single call All you need is an account or wallet address and you'll instantly get a full list of every single token and their balances held by that account. - Supports SPL tokens and Token-2022 - Fetch all tokens and balances in USD - Auto-updated with new activity ## Get metadata for any fungible token Return important token information including the account balance, program address, associated token address, total supply in circulation, price, and more. - Get verification status and token prices in USD - Supports SPL as well as Token22 extension - Backwards compatible with the original DAS API ## Get all transactions associated with any token Get complete history for any token including every single transfer, swap, and application interaction across accounts. - Filtered by event type - Auto-updated with new activity ## Parse token transactions to make them easy to read The Parsed Events API decodes over 3,600 programs from their onchain IDLs to give you clear, structured data about what happened during transactions. - Named instructions, accounts, and every token transfer - Plain-language summaries for all named events - Parse signatures or wallet history (REST or GraphQL) ## Solana Token APIs for every use case - **Wallets**: Get a complete view of all tokens held by an account including token and USD balances. - **Trading platforms**: Power your platform with reliable token metadata and important metrics like price, market cap, and holder count. - **Portfolio trackers**: Build user-friendly dashboards that enable users to track and analyze their token holdings. - **DeFi dashboards**: Track any token on Solana with granular transaction data. Monitor supply changes, holder distribution and transaction patterns. - **Blockchain explorers**: Build human-readable block explorers by extracting and parsing metadata and activity for any token. - **Token-gated experiences**: Gate access to your app based on token ownership. Verify holdings and transactions in real-time for seamless authorization. ## Frequently Asked Questions ### What token standards do Helius's Token APIs support? The [DAS API](/docs/das-api) covers SPL Token and Token-2022, including Token-2022 extensions, plus regular NFTs and compressed NFTs. Plain SPL mints without metadata are included. One set of methods returns balances, supply, metadata, ownership, and USD prices for verified tokens. To read what a token transaction did, the [Parsed Events API](/parsed-data) decodes instructions from more than 3,600 programs. ### How much do Helius's Token APIs cost? Every DAS API request costs 10 credits. Each Parsed Events request also costs 10 credits. Both use the same monthly allowance as RPC: 1 million credits on Free ($0), 10 million on Developer ($49), 100 million on Business ($499), and 200 million on Professional ($999). Additional credits are $5 per million. See the [credits docs](/docs/billing/credits). ### What are Helius's Token API rate limits? Token API calls use the DAS and Enhanced API limit, which is separate from RPC rate limits. That limit is 2 requests per second on Free, 10 on Developer, 50 on Business, and 100 on Professional. Enterprise limits are custom. See [rate limits](/docs/billing/rate-limits). ### What is the difference between the DAS API and Parsed Events? The DAS API returns the current state of an asset: balances, metadata, price, ownership, and search. Parsed Events turns a signature, or a wallet's history, into named instructions, accounts, token transfers, and a plain-language summary. Use DAS for holdings and token data, and Parsed Events to read what a transaction did. Docs: [DAS API](/docs/das-api) and [Parsed Events](/docs/parsed-events). ### Can I fetch every token a wallet holds in one call? Yes. Pass a wallet address to `getAssetsByOwner` and the DAS API returns the SPL and Token-2022 tokens that address holds, with balances. Verified tokens include a USD price. The walkthrough is in [get tokens](/docs/das/get-tokens). ### How can I get started with the DAS API? To get started, explore these resources: - [DAS API Documentation Overview](/docs/das-api) - [Get Tokens](/docs/das/get-tokens) - [DAS API Reference](/docs/api-reference/das) - [Get NFTs](/docs/das/get-nfts) - [Search Assets](/docs/das/search) ## Ready to build? Get started in less than 10 seconds. No credit cards or email required. [Start for free](https://dashboard.helius.dev/signup) | [Learn more](https://www.helius.dev/docs/das-api) --- ## Solana vs. Ethereum: Technical Comparison for Developers _Source: https://www.helius.dev/solana-vs-ethereum.md_ > Explore concepts, programming models, tools, fees, and more --- ## Solana WebSockets and Webhooks _Source: https://www.helius.dev/solana-webhooks-websockets.md_ > Stream real-time Solana events like transactions, sales, and swaps in with our fault-tolerant, low latency Webhooks and WebSockets solutions. ## Stream or push Solana data in real-time Stream with LaserStream WebSockets or push with Webhooks to deliver on-chain updates in real time. [Start for free](https://dashboard.helius.dev/signup) | [Documentation](https://www.helius.dev/docs/rpc/websocket) ## Every single update, delivered instantly Our WebSockets and webhooks deliver the latest transaction and account updates to you as soon as they occur onchain so your app is always in sync with Solana. ## Build apps powered by real-time Solana data - **Wallets**: Give users responsive, real-time balance updates, transaction alerts, and activity logs. - **Portfolio trackers**: Provide users, up-to-date information on their open positions, NFTs, and tokens. - **Crypto social apps**: Notify users when friends perform actions onchain like posting, trading or betting. - **NFT marketplaces**: Instantly notify users about listings, bids, and sales to create seamless experiences. - **Analytics platforms**: Give users the most accurate view of Solana by serving precise onchain analytics data. - **Gaming & virtual worlds**: Stream onchain alerts for in-game sales, achievements, mints, rewards, and loot. ## Your Competitive Edge for Real-time Data Be the first to see and trade on every market movement. [Learn more](https://www.helius.dev/laserstream) ## Frequently Asked Questions ### When should I use WebSockets vs. gRPC? Choose LaserStream WebSocket when latency, continuity, and correctness don't affect PnL, fills, or risk; you want JSON payloads; or you're building consumer UX without backend complexity. Choose LaserStream gRPC when latency, continuity, and correctness do affect PnL, fills, or risk; you need advanced filtering; you need gapless delivery with automatic replay; or you need transactions at multiple commitment levels. ### What Enhanced WSS data add-on plans are available, and how much do they cost? [Data add-on plans](/docs/billing/plans#data-add-ons) for Enhanced WebSockets include: 5TB ($400/mon), 10TB ($750/mon), 25TB ($1,750/mon), 50TB ($3,250/mon), and 100TB ($6,000/mon). For larger data add-ons and volume-based pricing, please [contact sales](https://form.typeform.com/to/KiacmxpZ). ### When are webhooks automatically disabled? Webhooks with a failure rate of 95% or higher are automatically disabled to protect your system and eliminate wasted delivery attempts. Free plan webhooks are evaluated over a 24-hour window, while paid plan webhooks are evaluated over a 7-day window. Customers on the Developer plan and above will receive an email notification whenever a webhook is automatically disabled, so you can take action quickly. ### How do I re-enable a disabled webhook? Log in to your Helius dashboard, navigate to the Webhooks section, and toggle your webhook back on. After re-enabling, your webhook has a 24-hour grace period before it is evaluated again, so you have time to fix the underlying issue. You can also use the [Toggle Webhook endpoint](/docs/api-reference/webhooks/toggle-webhook) to programmatically re-enable a disabled webhook. ### How can I get started with Webhooks and WebSockets? To get started, explore these resources: - [Webhooks Documentation Overview](/docs/webhooks) - [Webhooks Quickstart](/docs/webhooks/quickstart) - [Webhooks API Reference](/docs/api-reference/webhooks) - [Webhook Transaction Types](/docs/webhooks/transaction-types) - [LaserStream WebSocket Overview](/docs/rpc/websocket) ## Ready to build? Get started in less than 10 seconds. No credit cards or email required. [Start for free](https://dashboard.helius.dev/signup) | [Learn more](https://www.helius.dev/docs/rpc/websocket) --- ## Solana Staking: Stake with Helius _Source: https://www.helius.dev/stake.md_ > Stake Solana (SOL) and earn yield. Highest APYs. Connect your wallet. Native staking. Liquid staking (hSOL). Manage stake accounts. Institutional-grade. ## Stake Solana Earn the highest APYs on Solana thanks to zero commission and unmatched block production. As the largest validator on the network, Helius passes 100 percent of rewards to you while helping Solana reach consensus faster and stay more secure. ## Frequently Asked Questions ### How are staking rewards calculated? Your staking rewards are based on your share of the total amount of SOL staked to the Helius validator, the duration with which you've staked your SOL, and the total amount of rewards earned by the validator. Helius stakers receive 100% of all SOL issuance rewards and 100% of all MEV rewards. For more details, read our [Complete Guide to SOL Staking](https://www.helius.dev/blog/solana-staking-simplified-guide-to-sol-staking) article. ### How can I estimate my SOL staking rewards? Visit our [Solana Staking Calculator](https://www.helius.dev/staking/calculator) to estimate your expected rewards and compare native staking providers, LSTs, and stake pools. ### How can I integrate staking into my app? The Helius SDK makes it simple to add staking to your app or platform. Follow our [step-by-step guide](https://www.helius.dev/docs/staking/how-to-stake-with-helius-programmatically) to stake programmatically using our tools. Perfect for wallets, dashboards, or any Solana app that wants to support native staking. ### Does Helius offer a Solana Staking API? Developers can [programmatically stake](https://www.helius.dev/docs/staking/how-to-stake-with-helius-programmatically) to Helius using our Node.js SDK to achieve the same functionality as a Solana Staking API. Build, sign, and send transactions in just 8 lines of code. ### How do I harvest MEV for native stake accounts? Native Helius validator stakers can harvest their MEV rewards using Jito's [MEV harvesting tool](https://www.jito.network/harvest/). First, connect your wallet to see all of your active stake accounts. By default, all accounts will have the "Claim MEV" switch toggled ON. If you don't want to claim MEV for a particular account, toggle this switch OFF. By default, you will claim rewards in the JitoSOL token. If you want to claim rewards as SOL, toggle the "Convert MEV to JitoSOL" button OFF. Then, click "Harvest MEV as SOL," and sign your wallet transaction. ### What is native staking vs. liquid staking? In native staking, your SOL tokens are delegated to a validator and become locked until you unstake your SOL and wait until the end of the current epoch. This means, while your SOL is staked natively, you are unable to use it with other applications. With liquid staking, you swap your SOL tokens for a Liquid Staking Token (LST) — hSOL — which represents your staked SOL. The hSOL token automatically accrues staking rewards, and can be used across DeFi applications. To unstake, simply swap hSOL to SOL with no cool down period. ### What staking fees does Helius take? Helius takes 0% fees on SOL issuance and 0% fees on MEV rewards. For comparison, institutional validators like Coinbase, Figment, and Galaxy take 8%, 7%, and 5% commission respectively. ([Source](https://solanabeach.io/validators)) ### Why should I stake with Helius? Staking with Helius makes a direct impact on securing and accelerating the Solana blockchain while giving 100% of staking rewards back to stakers. Our ultra-low skip rates, high vote rates, and 0% fees means the network is able to produce more blocks, reach consensus faster, and provide stakers the highest APYs. Need more information? Learn about the Helius validator, commissions, and benefits. [Learn more](https://www.helius.dev/validator) --- ## Staked Connections: Priority Lane for Solana Transactions _Source: https://www.helius.dev/staked-connections.md_ > Guarantee Solana transactions land on-chain by sending them through staked endpoints. Included with all paid plans by default. **Staked Connections** ## Your priority lane for
landing Solana transactions Guarantee transactions land on-chain by sending them through staked endpoints. Included with all paid plans. [Get started](https://dashboard.helius.dev/signup) | [Documentation](https://www.helius.dev/docs/sending-transactions/send-manually) **LAND FASTER** ## Unmatched bandwidth and performance Experience faster delivery, industry-leading reliability, and unmatched bandwidth when you send transactions through staked connections, backed by Solana's top validator by stake. ## Latency-sensitive? Use Helius Sender Staked connections power reliable, credit-billed basic sending. If milliseconds decide your trades, Helius Sender routes across every high-speed pathway. [Explore Sender](https://www.helius.dev/sender) ## Submit, land, and confirm transactions — faster Our RPCs deliver the fastest speeds and lowest latencies, with industry-leading transaction-sending success rates. - **Over99.99%**: Transaction landing rate - **Less than1s**: Confirmation time [Get started](https://dashboard.helius.dev/signup) **See also:** - [Test Solana RPC Providers](https://www.helius.dev/benchmarks): Benchmark Solana RPC latency across providers ## Dependable delivery,
every time No matter the market conditions on Solana, guarantee customer's transactions land without fail using our top-staked validator and global RPC fleet. - #1 Solana validator with over 14M SOL staked - Global fleet of RPC clusters with regional routing - Flexible rate limits to meet internet-scale demand > "Helius has been a game-changer for us with extremely reliable RPCs alongside Webhooks that have enabled a whole new set of use cases at a great price." > — Luke Truitt, CEO & Co-founder, Loopscale ## Trusted by Solana's best > "We tried every strategy to land transactions on Solana, but nothing was working. The moment we switched our RPCs to Helius and started sending transactions through staked connections, all of our problems disappeared. Now we can confidently scale our business on Solana without worrying about our customer's transactions getting dropped." — **Cody Lambert**, SOFTWARE ENGINEER, BRALE, Brale ## Frequently Asked Questions ### What are staked connections? Staked connections route your transactions directly to current and upcoming block leaders, bypassing public queues for near-guaranteed delivery. All paid plans automatically use staked connections by default - no code changes required. Learn more in our transaction sending overview. ### Why do I need a Staked Connection for my Solana projects? If your application requires predictable and low-latency landing rates on Solana, a staked connection is essential because it mitigates the risk of dropped transactions and long processing times, which are common issues with unstaked endpoints, especially during periods of high network activity. ### How is a Staked Connection different from a standard RPC endpoint? A standard (or "unstaked") RPC endpoint sends transactions to the public transaction processing queue, where they compete with all the other network traffic. This can lead to transactions being delayed or failing. A staked connection, on the other hand, utilizes our staked SOL to gain priority access, sending your transactions directly to the block leader. This ensures a higher rate of success and minimal latency. For comparison, there are 500 ### Are staked connections available on all shared plans? Yes, staked connections are available on all of our shared, paid plans. Staked connections are not available on free plans, nor are they included with dedicated nodes. ### Do dedicated nodes include staked connections? No. Dedicated nodes do not include staked connections by default. We recommend purchasing a shared plan for sending transactions in addition to using a dedicated node for handling RPC or gRPC requests. ### Can I purchase standalone staked connection bandwidth? Yes, you can purchase a staked connection endpoint as a standalone product. Please contact our sales team to assist with this request. ### When should I choose staked connections vs. Sender? If you are an HFT trader, MEV searcher, arbitrager, token sniper, or generally need the lowest latency landing rates with the highest guarantees, you should use Sender. If latency is not essential for your core business, staked connections included on all shared plans will generally be sufficient for your use case (e.g., wallets, DeFi, social apps, etc.) ## Try Helius for free Get 1M credits for free. Get started in less than 10 seconds. No credit cards or email required. [Start for free](https://dashboard.helius.dev/signup) | [Learn more](https://helius.dev/docs) --- ## Solana (SOL) Staking Rewards Calculator (2026) _Source: https://www.helius.dev/staking/calculator.md_ > Calculate daily, weekly, monthly, and annual SOL staking rewards. Compare any two Solana validators, LST, or stake pools. **SOL STAKING CALCULATOR** ## Calculate Solana Staking Rewards Estimate SOL staking yields (APY) and compare validators, LSTs, and Solana stake pools ## Maximize native staking rewards with enterprise-grade validators ## Trusted by Solana's best > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM ## Frequently Asked Questions ### What is Solana staking and how does it work? Solana staking is the process of locking up SOL tokens and delegating them to a validator on the network in exchange for new SOL tokens issued as rewards. Proof-of-Stake blockchains like Solana use stake to secure the network. Staking rewards are distributed once per epoch (approximately every 2 days), or automatically accrue to Liquid Staking Tokens (LSTs) like Helius's hSOL token. ### How are Solana staking rewards calculated? Solana staking rewards are calculated by adding together your share of a validator's issuance rewards, MEV rewards, and in some cases, block rewards, minus any validator commission fees. Rewards are based on Solana's inflation rate, staking ratio, the total amount of SOL staked to your validator of choice, your share of the staked SOL, and the validator's performance. ### What are validator commission fees and how do they affect my staking rewards? Validators charge a fee, or commission, on the staking rewards they earn. This percentage is deducted from your gross rewards before they are paid out to you, directly impacting your net APY. Validators that charge fees typically charge them on inflation rewards and MEV rewards. 0% commission validators like Helius pass all inflation and MEV rewards back to the stakers. ### What is the difference between native staking and liquid staking? Native staking is the process of delegating SOL tokens directly to a validator through a stake account. Native staking rewards are automatically shared with you at the end of an epoch, and MEV rewards can be harvested through Jito. Liquid staking is the process of swapping SOL for a Liquid Staking Token (LST) like hSOL which represents your share of the validator's total stake. LSTs automatically accumulate inflation and MEV rewards. ### How does compounding work for native staking and liquid staking? Newly issued SOL from Solana staking rewards are automatically deposited back into the stake account that earned them at the end of each epoch. As soon as the SOL rewards are deposited into your account, they become part of your active stake for the next epoch, thereby you'll be earning rewards on a slightly larger principal. MEV rewards accrue separately and must be claimed through Jito. Liquid Staking Tokens compound by automatically accruing staking and MEV rewards to the LST, increasing its price. ### What is Solana’s inflation rate? Solana’s current inflation rate is 4.349%. Solana started at an 8% inflation rate and decreases approximately 15% per epoch year (~182.5 epochs) with a target long-term inflation rate of 1.5%. ### How do I delegate stake to Helius’s validator? You can delegate stake to Helius’s validator natively or through a Liquid Staking Token. To natively stake to our validator, use our staking portal, stake directly through wallets like Phantom, or stake through qualified custodians like BitGo. To stake to our validator through an LST, you can swap SOL for hSOL on most major Decentralized Exchanges. ### Who should run a white label validator and what is the primary benefits? Entities with large amounts of SOL (over 80,000 SOL tokens) should consider running a white label validator. The primary benefit of running your own validator through a Validator-as-a-Service provider, such as Helius, is to earn a higher staking APY. By running your own public or private validator, you keep the block rewards (i.e. base fees and priority fees), and earn more rewards. ### How long does it take to unstake SOL tokens? Unstaking usually takes up to 2 days. First, stakers must deactivate their stake, and once the current epoch ends, they can withdraw their SOL from the stake account. During the deactivation period, your SOL tokens are not available for trading or transferring to another wallet. If you want the ability to immediately unstake SOL tokens, consider using a Liquid Staking Token like Helius’s hSOL. ## Run a White Label Validator Have more than 80k SOL? Run a validator with Helius. [Contact us](https://www.helius.dev/contact) --- ## Compare Solana (SOL) Staking Rewards and APYs _Source: https://www.helius.dev/staking/rewards.md_ > Discover which Solana validators, LSTs, and stake pools offer the best Solana (SOL) staking yields. Compare APY, commission fees, and total stake. **WHERE SHOULD I STAKE SOL?** ## Solana Staking Rewards Explore Solana validators, staking pools, and Liquid Staking Tokens (LSTs) to find the best APY for your SOL. ## Frequently Asked Questions ### How are Solana staking rewards calculated? [Solana staking rewards are calculated](https://www.helius.dev/staking/calculator) by adding together your share of a validator’s issuance rewards, MEV rewards, and in some cases, block rewards, minus any validator commission fees. Rewards are based on Solana’s inflation rate, staking ratio (~65%), the total amount of SOL staked to your validator of choice, your share of the staked SOL, and the validator's performance. Solana’s total issuance rewards are distributed proportionally among all stakers that are actively staked. Lastly, the more stake a validator has, the more blocks it has the opportunity to produce and the more MEV tips it may earn. If you receive a portion of your validator’s block rewards, the better your validator is at packing blocks with transactions, the higher the rewards will be. ### How do validator commission fees affect my staking rewards? Validators charge a fee, or commission, on the staking rewards they earn. This percentage is deducted from your gross rewards before they are paid out to you, directly impacting your net APY. Validators that charge fees typically charge them on inflation rewards and MEV rewards. [Validators that charge 0% commission](https://www.helius.dev/validator) like Helius pass all inflation and MEV rewards back to the stakers. ### How do I choose a Solana validator with which to stake my SOL? Choosing a Solana validator to stake SOL with involves considering a few criteria including the validator’s commission fees, staking APY, validator uptime, skip rate, sandwich rate, compute units, and reputation. If you’re an institution, additional considerations include [SOC II compliance](https://www.helius.dev/blog/soc2), security, integrations with qualified custodians, customer support, and monthly reporting. ### How does running a white label Solana validator increase staking rewards? Entities that [run their own Solana validator](https://www.helius.dev/validator-as-a-service) can earn more SOL staking rewards by keeping the block rewards, or the base fees and priority fees, which are not typically shared with native stakers and liquid stakers because there is no in-protocol method for distributing block rewards to stakers. This can add an additional 0.5-1.5% APY to your Solana staking returns. ## Stake with us Earn rewards and secure the network by staking to Solana's most trusted validator. [Get started](https://www.helius.dev/stake) --- ## Helius Startup Launchpad _Source: https://www.helius.dev/startup-launchpad.md_ > Accelerate your Startup on Solana with 8 months of free Business tier access, warm intros, and strategic mentorship from Solana's leading operators. ## Accelerate Your Startup on Solana Scale, speed, and support. Everything your startup needs to succeed. Join the Helius Startup Launchpad and get 8 free months of our Business plan, intros to investors, mentorship from Solana's leading operators, and countless exclusive vendor discounts. [Apply now](https://form.typeform.com/to/uShCvuLv) | [Become a partner](https://form.typeform.com/to/murJcQm2) ## Increase the economic potential of the world's developers with crypto Accelerate internet capital markets on Solana. Build high-performance infrastructure and developer tooling to scale crypto's most ambitious startups. ## Exclusive Perks Don't let a small budget stop you from building a world-class product. Get enterprise tools at founder-friendly prices. - Helius — 8 months free Business plan ($4K value) - Squads — 20% off treasury management tools - Ottersec — 10% off audits and consultations - Switchboard — no oracle integration fees - Loop — 0% fees on your first $5K payments *Plus MoonPay, Sphere, Dynamic, and more!* ## Some of our partners ## Build a generational startup on Solana Crypto founders often excel at engineering but have limited experience managing all the business functions required to scale. This ends now. - **Discounts**: Get exclusive discounts from Helius and our partners including audits, treasury management, embedded wallets, and more. - **Mentorship**: Unblock your growing pains with expert advice from veteran operators across every discipline including marketing, sales, talent, operations, and design. - **Introductions**: Work with angels and partners at crypto's most influential VC firms to get warm intros to investors, marquee customers, talent, strategic advisors, and more. - **Strategy**: Work with strategic advisors to profitably scale your company including help with product, pricing, branding, tax, and legal. - **Access**: Get access to private group chats to connect with other founders, investors, and operators in Solana. - **Education**: Attend VIP workshops and private office hours to get hands-on guidance for everything from pitch deck reviews to advanced compute unit optimizations. ## Eligibility Criteria This program is for founders who ship fast, iterate faster, and build for the long term. We're looking for teams with some combination of the following: - Have a working product - Have not raised a Series A or later - Graduated from other startup accelerators (e.g. Colosseum, Alliance, Solana Labs Incubator) - Are referred by VCs and well-known angels - Have won or placed at recent Solana hackathons *If you have what it takes, apply now.* > "Helius has been awesome. When daos.fun went viral, we needed to scale fast. Helius was the only provider that responded immediately on a Saturday night, and has been available 24/7 to help us with any issue." — **baoskee**, Founder, daos.fun, daos.fun ## Frequently Asked Questions ### I won or placed in a recent Solana hackathon. Am I automatically accepted? No. Teams that have won or placed in recent Solana hackathons are not automatically accepted to the Startup Launchpad. Teams will be evaluated on the merits of their product, traction, and other eligibility criteria. ### When is the application deadline? There is no application deadline for the Startup Launchpad. Startups and partners are encouraged to apply at any time. ### My company raised a Series A round. Are we eligible? No, companies that have raised a Series A round (or later) are not eligible for the Startup Launchpad. ### Are existing Helius customers eligible for the Startup Launchpad? Yes. This program is open to new and existing Helius customers. ### Are additional Helius credits covered by the Business tier discount? No. Additional credits are not covered by the Business tier discount. If you exceed your plan's 100M credit limit, you will be charged the standard rate of $5 per million credits as described in our [pricing documentation](https://docs.helius.dev/welcome/pricing-and-rate-limits#extra-credits). ### How do I redeem my 8 months of free Business tier access? After we approve your application, we will apply a coupon code to your account. This code will apply a 100% discount to your Business plan for 8 months. [Talk to an expert](https://t.me/bradyowen) ## Ready to build? Apply to the Helius Developer Launchpad. Or sign up to become a partner. [Apply Now](https://www.helius.dev/contact) | [Become a Partner](https://www.helius.dev/contact) --- ## Helius Validator: Solana's Most Trusted Validator _Source: https://www.helius.dev/validator.md_ > 0% commission. 100% MEV rewards. Highest APYs in Solana. Learn about our institutional staking options and liquid staking token, hSOL. ## Stake with Solana’s Top Validator 0% fees. 100% inflation rewards. 100% MEV rewards. Stake natively, with the hSOL liquid staking token, or any major qualified custodian: BitGo, Fireblocks, and Anchorage. [Stake with us](https://www.helius.dev/stake) | [Talk to Sales](https://www.helius.dev/contact) ## Why is Helius the best Solana validator? - **Global, redundant coverage**: We have validators in Amsterdam and Frankfurt with two fallback replicas that we can fail over to in 10 seconds. - **SOC 2 Type II Compliance**: We are SOC 2 Type II compliant, meaning we have undergone a rigorous audit to ensure our systems are secure and reliable. - **Yield optimizations**: Multiple performance improvements are underway to improve yield generation such as Timely Vote Credits (TVC). - **Zero downtime**: Our devops engineers use blue–green deployment methods to conduct upgrades with zero downtime. - **Solana-native team**: Our team is solely dedicated to the Solana ecosystem — it has our undivided attention every single day. - **24/7 support**: Our team is distributed around the world, enabling us to provide you or your company with 24/7 support. ## Secure Solana, earn rewards - **0% Fees**: We take 0% fees compared to other institutional-grade validators which typically take between 5% - 8% commission. - **100% MEV Rewards**: We give 100% of MEV rewards to stakers. This happens automatically through hSOL, and can be manually claimed through Jito. - **7%–9% APY***: Get Solana's highest APYs while maximizing the network's performance. *Estimated APY based on chain activity. > "We're thrilled to partner with Helius in building our own Solana validator for the Bitwise Solana Staking ETF. Not only is Helius the standard bearer for Solana validators when it comes to areas like performance, reliability, and security, but their native understanding of Solana and its ecosystem is unmatched. They've helped us build the perfect high performance validator—one that meets our stringent needs around security and reporting as an ETF issuer." — **Hong Kim**, CTO, BITWISE ASSET MANAGEMENT, Bitwise ## Frequently Asked Questions ### Is Helius SOC 2 certified? Yes, Helius is SOC 2 Type II certified. We completed our audit and received a clean report from Sensiba LLP in Q2 2025. You can read more in our [SOC 2 announcement](/blog/soc2), and request a copy of the report from our [Trust Center](https://security.helius.dev/). ### Does Helius offer a Solana Staking API? Developers can [programmatically stake](/docs/staking/how-to-stake-with-helius-programmatically) to Helius using our Node.js SDK to achieve the same functionality as a Solana Staking API. Build, sign, and send transactions in just 8 lines of code. ### Does Helius offer a Solana Stake Reporting API? We provide individuals and companies with large amounts of SOL staked to Helius’ validator with stake reporting dashboards upon request. Currently, we do not provide a Solana Stake Reporting API. ### Should I stake to Helius’ public validator or run a white label validator? If you own less than 80,000 SOL, we recommend staking to Helius’ public validator given the hardware and Validator-as-a-Service management costs. If you hold more than 80K SOL, running a white label validator may result in higher rewards. To calculate your SOL rewards for staking to Helius vs. other institutional staking platforms and running a white-label validator, [contact our sales team](https://form.typeform.com/to/q9siieUi). ### How can I get started with staking to the Helius Validator? To get started, explore these resources: - [Stake with Helius](/stake) - [Staking Calculator](/staking/calculator) - [Compare Staking Rewards](/staking/rewards) - [Programmatic Staking Guide](/docs/staking/how-to-stake-with-helius-programmatically) ## Ready to stake? Swap SOL for hSOL, or contact our team to inquire about institutional staking services. [Stake with us](https://www.helius.dev/stake) | [Talk to Sales](https://www.helius.dev/contact) --- ## Solana Validator-as-a-Service _Source: https://www.helius.dev/validator-as-a-service.md_ > Fully managed white label Solana validators. Maximize your rewards by leveraging the experience of Solana's most trusted infrastructure provider. ## Managed white label Solana validators Earn the highest staking rewards with a branded, institutional-grade Solana validator. Safely maximize your rewards by leveraging the experience of Solana's most trusted SOC 2 certified infrastructure provider. [Contact us](https://www.helius.dev/contact) ## Reliable, high-performance validators trusted by enterprises Meet regulatory and compliance requirements with a SOC 2-compliant, production-ready validator run by Solana's most trusted staking services provider. Earn revenue, secure Solana, and scale with peace of mind. ## What are the benefits of running white label validators? - **Earn more rewards**: Capture block rewards in addition to earning 100% of inflation and MEV rewards. Generate higher yields compared to native staking. - **Customize control**: Set your own commission rates, control reward distributions, choose your validator client, and select your validator's location. - **Offer staking to clients**: Receive stake delegations from clients and add staking functionality directly into your application's interface using the Helius SDK. - **Integrate with DeFi**: Launch a Liquid Staking Token (LST) and integrate it with Solana DeFi apps like lending platforms and decentralized exchanges. - **Build your brand**: Become a trusted entity in the Solana ecosystem, engage in governance, and vote on Solana Improvement Documents (SIMDs). - **Decentralize Solana**: Add to Solana's decentralization by running a full validator node that builds blocks, votes in consensus, and secures the network. ## Who should run a white label validator? - **Asset Managers**: Earn full rewards on large volumes of SOL acquired through ETFs, initial token sales, and estate purchases. - **Custodians**: Set up a white label validator on behalf of your customers, while maintaining control over fees and rewards. - **Wallets**: Allow users to quickly stake SOL and earn rewards directly from your mobile wallet or browser extension. - **Exchanges**: Offer customers Solana staking services and competitive APYs directly on your exchange. Set custom fees for full control. - **Applications**: Earn yield on staked SOL and leverage your managed validator's stake to improve transaction landing rates with swQoS. - **Corporate Treasuries**: Stake your company's SOL treasury to a public or private validator that is compliant, regulated, and secure. ## Why choose Helius to run your validator? - **Highest APYs**: Maximize block rewards and generate the highest staking yields without jeopardizing the security of the network. - **Enterprise-grade**: We are a SOC2 certified company, compatible with qualified custodians like BitGo, have 100% uptime, and 24/7 customer support. - **Real-time reporting**: Track staking rewards, APY, and total stake by epoch with a custom, real-time dashboard for accurate reporting and tax calculations. ## Maximize validator revenue per block Access the latest hardware and network optimizations to maximize revenue per block, vote on consensus, and minimize skip rates. - **Over99.9%**: Slot success rate > "Not only is Helius the standard bearer for Solana validators when it comes to areas like performance, reliability, and security, but their native understanding of Solana and its ecosystem is unmatched." > — Hong Kim, CTO, Bitwise Asset Management ## Battle-tested infrastructure Maximize uptime and avoid missing blocks by leveraging our fault-tolerant, globally distributed systems and state-of-the-art devops. - **Uptime**: 100% - **Data centers**: 11 > "When it comes to SOL staking, Helius is truly differentiated. Helius is the industry leader when it comes to running secure, reliable, and performant validators." > — Cosmo Jiang, General Partner at Pantera Capital and Board Observer at HSDT ## 24/7 expert assistance Solana moves fast, and so do we. We'll handle everything from client upgrades to emergency patches so your team can focus on your core business. - Solana-native engineers - Block reward optimizations - Timely validator client upgrades - 10 min. median support time - VIP support channels ## For enterprises and institutions Ideal for teams operating at scale or with custom compliance requirements - Supports BitGo, Fireblocks, Anchorage - Tailored deployments - SOC 2 compliant - Custom support SLAs - Robust firewall configurations - Secure key management - Real time staking dashboards - Best-in-class validator security - Comprehensive reward reporting - Direct access to our engineering team [Contact us](https://www.helius.dev/contact) ## Trusted by Solana's best > "We're thrilled to partner with Helius in building our own Solana validator for the Bitwise Solana Staking ETF. Not only is Helius the standard bearer for Solana validators when it comes to areas like performance, reliability, and security, but their native understanding of Solana and its ecosystem is unmatched. They've helped us build the perfect high performance validator—one that meets our stringent needs around security and reporting as an ETF issuer." — **Hong Kim**, CTO, BITWISE ASSET MANAGEMENT, Bitwise ## Frequently Asked Questions ### Is there a minimum amount of stake required for white label validators? Below 80,000 SOL, staking to the [public Helius validator](/validator) is usually the better choice once hardware and management cost are included. Above 80,000 SOL, a white label validator can return more. [Contact sales](/contact) for a rewards comparison. ### What validator operations does Helius manage? Helius manages the validator: hardware, client upgrades, emergency patches, block-reward tuning, firewalls, key management, monitoring, reporting, and failover. ### What validator reporting or dashboards does Helius provide? Each deployment includes a real-time dashboard for staking rewards, APY, and total stake by epoch, plus detailed monthly reporting across stake, rewards, and APY for auditing, compliance, and tax requirements. ### Does Helius offer additional ways to monetize Solana validators? A white label validator earns inflation rewards, Jito MEV tips, and block rewards from priority fees. Contact us to discuss additional [validator monetization](/validator-monetization) opportunities. ### Is Helius SOC 2 Type II certified? Yes. Helius completed a SOC 2 Type II audit and received a clean report from Sensiba LLP in Q2 2025. Read the [announcement](/blog/soc2), or request the report from the [Trust Center](https://security.helius.dev/). ### Do I keep custody of the SOL staked to a white label validator? Yes. Helius only operates the validator; we do not take custody of the SOL. Supported custodians include BitGo, Fireblocks, and Anchorage. ### How can I get started with Helius Validator-as-a-Service (VaaS)? To get started, explore these resources: - [Validator-as-a-Service Contact](/contact) - [Validator Monetization](/validator-monetization) - [Programmatic Staking Guide](/docs/staking/how-to-stake-with-helius-programmatically) ## Ready to build? Contact our team to explore the best Solana validator and staking solution for your company. [Contact us](https://www.helius.dev/contact) --- ## Validator Monetization: Boost Your Solana Validator Rewards _Source: https://www.helius.dev/validator-monetization.md_ > Earn more from your Solana validator. Boost rewards; no validator client changes required. ## Boost your validator rewards Helius helps Solana validators earn more — with no changes to your validator client required. Keep running your node exactly as you do today and unlock additional rewards. --- ## Wallet API: Solana Wallet Data over REST _Source: https://www.helius.dev/wallet-api.md_ > Query Solana wallet balances, history, transfers, identity, and funding sources over REST. Human-readable amounts and USD values. **Wallet API (Beta)** ## Solana wallet data made easy One REST API for getting Solana wallet balances, history, identity, and funding sources. No Solana JSON-RPC methods to memorize or lamport math required. [Get started](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/wallet-api/overview) ## One REST API, all Solana wallet data - **1. Get an API key**: Sign up, get your Helius API key, and pass the `api-key` on the query string or as an `X-Api-Key` header - **2. Hit one REST path**: `GET /v1/wallet/{wallet}/balances`, identity, history, or any other Wallet API endpoint - **3. Drop it into your app**: Amounts are decimal-adjusted, identities are labeled, and data is correctly formatted; no extra steps required ### getWalletBalances ```javascript const getWalletBalances = async (address) => { const url = `https://api.helius.xyz/v1/wallet/${address}/balances?api-key=YOUR_API_KEY`; const response = await fetch(url); if (!response.ok) { throw new Error(`HTTP error! status: ${response.status}`); } const data = await response.json(); const solBalance = data.balances[0]; // SOL is always first when showNative=true console.log(`SOL Balance: ${solBalance.balance} SOL ($${solBalance.usdValue})`); console.log(`Page ${data.pagination.page} Total Value: $${data.totalUsdValue}`); console.log(`Token Count (this page): ${data.balances.length}`); // Display top holdings data.balances.slice(0, 5).forEach(token => { console.log(`${token.symbol}: ${token.balance} ($${token.usdValue || 'N/A'})`); }); return data; }; getWalletBalances("86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY"); ``` [Start building](https://dashboard.helius.dev/signup) [View docs](https://www.helius.dev/docs/wallet-api/overview) ## Wallet API use cases - **Wallet dashboards**: Balances, USD values, and metadata in one REST call. No DAS stitching or lamport math - **Portfolio trackers**: Use history and balance-at to reconstruct holdings and compute PnLs over time - **Payment processors**: Log transactions and transfers with counterparty, amount, mint, and direction - **Tax and accounting**: Get human-readable history with per-transaction balance holdings and changes - **Compliance and AML**: Look up known exchanges, treasury wallets, see how wallets were funded - **Explorers and analytics**: Get tags for over 21 million wallets to add account labels in your app ## Ship the wallet and data layer together Add non-custodial embedded wallets to your app with sign in option support for passkeys, email, and existing wallets via helius-wallet-kit [Learn more](https://www.helius.dev/docs/waas/overview) ## Know who a wallet is Resolve a Solana address or domain name to an identity. Supports 32,500+ labels and 21.5M+ tags. - Single lookup or batch up to 100 addresses - SNS and ANS custom TLDs resolve on mainnet - Supports labels for exchange addresses, protocol wallets, institutions, and flagged addresses [View docs](https://www.helius.dev/docs/wallet-api/identity) ## Trace who funded a wallet The original funding source of a wallet: who sent the first SOL, how much, and when. Funder name and type come from the same identity system. - Immediate funder address, amount, slot, and signature - Exchange, protocol, or unknown, labeled if we know it - Cache forever. A wallet's first funder never changes [View docs](https://www.helius.dev/docs/wallet-api/funded-by) **See also:** - [Find wallet funding data using Orb](https://www.helius.dev/docs/orb/explore-wallets#track-who-funded-a-solana-wallet): See how the Orb block explorer exposes funding info ## Wallet activity, fully parsed Transaction history with per-transaction balance changes in human-readable language. - Newest first, up to 100 transactions per page - `tokenAccounts=balanceChanged` for updates only - `amount` is already decimal-adjusted; no lamport math [View docs](https://www.helius.dev/docs/wallet-api/history) **See also:** - [Parsed Events & Streams](https://www.helius.dev/parsed-data): Get decoded transaction history for 3,600+ programs ## Frequently Asked Questions ### On what plans is the Wallet API available? Balances, historical balance (`balance-at`), history, and transfers are available on every [plan](/docs/billing/plans), including Free. Identity (single and batch) and funded-by require any paid plan (Developer and above) and return `403` on Free. ### How many credits does the Wallet API cost? Every Wallet API request costs 100 credits, including batch identity (up to 100 addresses in one call). See the full [credit table](/docs/billing/credits#wallet-api-credits). ### Which Wallet API endpoint should I use? Use [balances](/docs/wallet-api/balances) for the current portfolio, [balance-at](/docs/wallet-api/balance-at) for a holding at a past slot or timestamp, [history](/docs/wallet-api/history) for a full activity feed with per-transaction balance changes, and [transfers](/docs/wallet-api/transfers) when you only need sent or received payments with a counterparty. Use [identity](/docs/wallet-api/identity) to label a known exchange, protocol, or institution, and [funded-by](/docs/wallet-api/funded-by) to find the wallet that sent the first SOL. ### What's the difference between WaaS and the Wallet API? The Wallet API is the read path: get balances, history, identity, and funded-by wallet information over REST. WaaS is embedded wallets: create and sign transactions using `helius-wallet-kit`. ### On what plans is Helius Wallet-as-a-Service (WaaS) available? WaaS is in beta and available on all [paid plans](/docs/billing/plans) (Developer, Business, Professional, and Enterprise). It is not available on Free. ### How is Helius WaaS priced? There is no separate subscription and no per-user fee. Each signature costs 200 credits ($0.001 at the standard credit rate). Wallet creation is free. `signMessage`, `signTransaction`, and `signAndSendTransaction` each count as one signature. A signature is billed even if the transaction later fails onchain. A cancelled prompt is free. Track usage in the dashboard under WaaS → Analytics. See [WaaS credits](/docs/billing/credits#wallet-as-a-service-credits). ### How do I get started with embedded wallets? [Upgrade](https://dashboard.helius.dev) to a paid plan, create an API key, and install `helius-wallet-kit`. Wrap your app in `HeliusWalletProvider` and follow the [WaaS quickstart](/docs/waas/quickstart). ### How can I get started with the Wallet API? To get started, explore these resources: - [Wallet API Documentation Overview](/docs/wallet-api/overview) - [Wallet Balances](/docs/wallet-api/balances) - [Wallet History](/docs/wallet-api/history) - [Wallet Transfers](/docs/wallet-api/transfers) - [Wallet API Reference](/docs/api-reference/wallet-api) ## Wallet data without the complexity Skip raw Solana JSON-RPC methods, and start querying onchain wallet data in minutes [Start building](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs/wallet-api/overview) --- ## Helius vs. Alchemy: Solana RPC Comparison (2026) _Source: https://www.helius.dev/compare/alchemy.md_ > Compare Helius and Alchemy across Solana RPC performance, products, and cost. Includes open-source latency benchmarks. **Helius vs. Alchemy** ## Helius vs. Alchemy Solana RPC Provider Comparison Compare Solana RPC performance, product coverage, and cost. [Get started](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs) ## Helius is up to 2.9x faster with a 83.5% win rate vs. Alchemy across Solana RPC methods. Helius is a Solana-native RPC provider with deep domain-level expertise, exclusive products, and the most performant Solana infrastructure stack in the ecosystem. Alchemy is an EVM-focused, multichain RPC provider that supports core Solana functionality. [up to 2.9x faster](https://www.helius.dev/compare/alchemy#latency-table) ## Compare Helius product support vs. Alchemy Evaluate Helius and Alchemy on the feature support and products Solana developers and professional traders actually use. | Feature | Helius | Alchemy | | --- | --- | --- | | Core Solana RPCs | Yes | Yes | | Custom RPC Methods | gTFA, gTBA, etc. | gTFA support | | Core Solana WebSockets | LaserStream WSS (up to 200ms faster) | Standard WSS | | Solana Webhooks | Yes | Yes | | Wallet API | Yes | No | | Embedded Wallets | Yes | Yes | | Historical Solana Data | Custom RocksDB index (up to 2.5x faster) | Yes | | gRPC Data Streaming | LaserStream gRPC | Yes | | Parsed Streams And Events API | Yes | No | | Transaction Landing Service | Sender | No | | MEV Protection | Yes | Yes | | Transaction Rebates | Yes | No | | Preconfirmations (Preconfs) | Yes | No | | Raw Shred Delivery | Yes | No | | Decoded Shreds | Yes | No | | Dedicated RPC Nodes | Yes | No | | Solana Validator Rank* | #2 (15.9M SOL) | #50 (2.2M SOL) | | Validator as a Service | Yes | Yes | | Starting Paid Plan | $49/month, 10M Credits, 50 RPS | $104/month, 10M Requests, 300 RPS** | | Enterprise plans and SLAs | Yes | Yes | | Customer Support | 24/7 Slack and Telegram support | 24/7 Slack and Telegram support | *As of July 2026. See [staking rewards](https://www.helius.dev/staking/rewards) for the latest data. **Data for starting plan taken from Alchemy's suggested PAYG plan. ## Faster on the Solana RPC methods you call most Helius outperforms Alchemy on p95 latency across archival RPC calls (e.g., 2.5x faster getBlock calls) and heavy account-based calls (e.g., 5.9x faster getProgramAccounts calls). - **88.5 /100**: Helius's score vs. Alchemy (76.2) - **2.9x faster**: p95 getTransaction latency vs. Alchemy - **83.5%**: Head-to-head win rate vs. Alchemy ## Pioneering Solana infrastructure Since 2022 Helius has been the leader in reliable, scalable, and ultra-low latency Solana infrastructure, consistently developing new products, publishing governance proposals, and backing founders to accelerate Solana. - **Custom RPC methods**: Exclusive archival RPC methods like getTransactionsForAddress (gTFA) - **Custom archival layer**: Ultra-low latency archival reads on a purpose-built RocksDB index - **Custom edge network**: Gatekeeper edge routing plus a global fiber backbone for the fastest path to Solana - **Custom trading services**: ULL stack, from signal to execution, for HFTs, prop trading firms, and CEXs - **Multi-region reliability**: Multi-region support, redundant architecture, and automatic failover under load - **Agentic developer tooling**: SDKs, MCP, CLI, and an official Claude Code plugin for building with agents on Solana ## Which RPC provider should you pick? ### Choose Helius if... - You are a trading firm, propAMM, bot, or exchange - You need low-latency onchain signals and landing services - You need fast, reliable, and scalable archival data and RPCs - You care about Solana-specific SDKs, MCPs, and CLI support - You want to work with Solana experts, exclusive to the network ### Choose Alchemy if... - You are a multichain team starting to test Solana - Latency and scale are not critical factors for you - Solana is a secondary focus in a multichain product - You prioritize a single multichain vendor relationship - You do not need Solana-native engineers or expertise ## Switching from Alchemy to Helius - **Get your Helius API key**: Create a free account in under a minute - **Update your RPC URL**: Replace your Alchemy endpoint with your Helius RPC URL - **Propagate and verify**: Redeploy, test, and monitor performance ### Update RPC URL ```typescript // Before (Alchemy) const connection = new Connection( "https://solana-mainnet.g.alchemy.com/v2/YOUR_KEY" ); // After (Helius) const connection = new Connection( "https://mainnet.helius-rpc.com/?api-key=YOUR_KEY" ); ``` [Get started](https://dashboard.helius.dev/signup) | [Read docs](https://www.helius.dev/docs) ## Trusted by Solana's best teams > "The Helius team makes building on Solana smoother and easier. They've done an amazing job at streamlining and removing complexity from app development on the network." — **Anatoly Yakovenko**, CO-FOUNDER & CEO, SOLANA > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana. They power a great portion of our infrastructure at Backpack." — **Armani Ferrante**, CO-FOUNDER & CEO, BACKPACK > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." — **Jonathan Levin**, CEO AND CO-FOUNDER, CHAINALYSIS ## Choose Helius Work with a partner who deeply understands Solana infrastructure and is committed to the ecosystem. [Get started](https://dashboard.helius.dev/signup) --- ## Helius vs. Quicknode: Solana RPC Comparison (2026) _Source: https://www.helius.dev/compare/quicknode.md_ > Compare Helius and Quicknode across Solana RPC performance, products, and cost. Includes open-source latency benchmarks. **Helius vs. Quicknode** ## Helius vs. Quicknode Solana RPC Provider Comparison Compare Solana RPC performance, product coverage, and cost. [Get started](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs) ## Helius is more performant, has a wider offering of products, and is exclusive to Solana. Quicknode supports EVM and non-EVM chains with limited Solana product coverage and depth compared to Helius, which is solely dedicated to the Solana ecosystem. ## Evaluate Helius products and features vs. Quicknode Helius has a more comprehensive suite of Solana products and more advanced features than Quicknode, and offers them natively compared to Quicknode's third-party add-on marketplace. | Feature | Helius | Quicknode | | --- | --- | --- | | Core Solana RPCs | Yes | Yes | | Custom RPC Methods | gTFA, gTBA, etc. | No | | DAS API Support | Native | via Marketplace | | Core Solana WebSockets | LaserStream WSS (up to 200ms faster) | Standard WSS | | Solana Webhooks | Yes | Yes | | Wallet API | Yes | No | | Historical Solana Data | Custom RocksDB index | Default BigTable | | gRPC Data Streaming | LaserStream gRPC | via Marketplace | | Parsed Streams And Events API | Yes | No | | Priority Fee API | Yes | via Marketplace | | Transaction Landing Service | Sender | via Marketplace | | MEV Protection | Yes | via Marketplace | | Transaction Rebates | Yes | No | | Preconfirmations (Preconfs) | Yes | No | | Raw Shred Delivery | Yes | No | | Decoded Shreds | Yes | No | | Dedicated RPC Nodes | Yes | Yes | | Solana Validator Rank* | #2 (15.9M SOL) | #126 (637k SOL) | | Validator as a Service | Yes | Yes | | Starting Paid Plan | $49/month, 10M Credits, 50 RPS | $42/month, 80M Credits, 50 RPS** | | Enterprise plans and SLAs | Yes | Yes | | Customer Support | 24/7 Slack and Telegram support | Ticket-based and chat support | *As of July 2026. See [staking rewards](https://www.helius.dev/staking/rewards) for the latest data. **Confirm current Quicknode pricing on their website; plans change frequently. ## Helius vs. Quicknode p95 Solana RPC latency Open-source, non-gameable RPC benchmarking tool comparing top Solana RPC providers across methods, regions, and infrastructure. - **88.6 /100**: Helius's score vs. Quicknode (85.9) - **1.4x faster**: p95 getTransaction latency vs. Quicknode - **64.8%**: Head-to-head win rate vs. Quicknode ## Solana infrastructure built for speed and scale Experience unmatched performance, unlimited scale, and a seamless developer experience when you build on our enterprise-grade platform. - **Solana-only RPC extensions**: Ship faster with Helius-exclusive methods such as getTransactionsForAddress - **Optimized RocksDB archive**: Get data from a custom RocksDB archival layer tuned for ultra-low latency reads - **Edge Gateway and fiber backbone**: Get data and land trades faster with our edge gateway and global fiber network - **Trading-grade services**: Optimized landing services and ULL data feeds built for HFTs, prop desks, and CEXs - **Redundant by design**: Globally available, maximally redundant, and elastically scalable to support your traffic - **SDKs for humans and agents**: Official Rust and TypeScript SDKs, CLI, MCP, and an official Claude Code plugin ## Which RPC provider should you pick? ### Choose Helius if... - Latency, reliability, and global scale are non-negotiable - Solana is your primary chain and key to your product's success - You're a prop trading firm, HFT, searcher, propAMM, bot, or CEX - You need the strongest guarantees for landing transactions - You want to work with a team of dedicated Solana experts ### Choose Quicknode if... - You need one vendor across many L1s and L2s - Solana is a small share of your multichain traffic - You do not need exclusive Solana RPC methods or tools - Your use case is not complex and scale is not a concern - Your switching cost is prohibitively expensive ## How to Switch from Quicknode - **Get your Helius API key**: Sign up for free and create your API key - **Update your RPC URL**: Replace Quicknode's RPC URL with your Helius endpoint - **Deploy and test**: Deploy, test in staging, then cutover traffic on mainnet ### Update RPC URL ```typescript // Before (Quicknode) const connection = new Connection( "https://YOUR_ENDPOINT.solana-mainnet.quiknode.pro/YOUR_KEY" ); // After (Helius) const connection = new Connection( "https://mainnet.helius-rpc.com/?api-key=YOUR_KEY" ); ``` [Get started](https://dashboard.helius.dev/signup) | [Read docs](https://www.helius.dev/docs) ## Trusted by Solana's best teams > "The Helius team makes building on Solana smoother and easier. They've done an amazing job at streamlining and removing complexity from app development on the network." — **Anatoly Yakovenko**, CO-FOUNDER & CEO, SOLANA > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana. They power a great portion of our infrastructure at Backpack." — **Armani Ferrante**, CO-FOUNDER & CEO, BACKPACK > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." — **Jonathan Levin**, CEO AND CO-FOUNDER, CHAINALYSIS ## Pick Helius Choose a partner dedicated to scaling Solana and helping the ecosystem grow. [Get started](https://dashboard.helius.dev/signup) --- ## Helius vs. Triton: Solana RPC Provider Comparison (2026) _Source: https://www.helius.dev/compare/triton.md_ > Compare Helius and Triton across Solana RPC performance, products, and cost. Includes open-source latency benchmarks. **Helius vs. Triton** ## Helius vs. Triton Solana RPC Provider Comparison Compare Solana RPC performance, product coverage, and cost. [Get started](https://dashboard.helius.dev/signup) | [View docs](https://www.helius.dev/docs) ## Helius is up to 4.2x faster with a 97.9% win rate vs. Triton across Solana RPC methods. Helius is faster, more performant, and has a broader suite of products compared to Triton. Both teams are Solana-native and have made meaningful open-source contributions. [up to 4.2x faster](https://www.helius.dev/compare/triton#latency-table) ## Explore Helius product support vs. Triton Evaluate Helius and Triton's product coverage and pricing to see which provider is the better choice for your use case. | Feature | Helius | Triton | | --- | --- | --- | | Core Solana RPCs | Yes | Yes | | Custom RPC Methods | gTFA, gTBA, etc. | gTFA support | | Core Solana WebSockets | LaserStream WSS | Whirligig | | Solana Webhooks | Yes | Yes | | Wallet API | Yes | No | | Historical Solana Data | Custom RocksDB index (up to 6.0x faster) | Superbank | | Custom Edge Gateway | Gatekeeper | No | | gRPC Data Streaming | LaserStream gRPC | Fumarole | | Parsed Streams And Events API | Yes | No | | Dedicated RPC Nodes | Yes | Yes | | Transaction Landing Service | Sender | Cascade | | MEV Protection | Yes | Yes | | Transaction Rebates | Yes | No | | Preconfirmations (Preconfs) | Yes | No | | Raw Shred Delivery | Yes | Yes | | Decoded Shreds | Yes | Yes | | Solana Validator Rank* | #2 (15.9M SOL) | #346 (164k SOL) | | Validator as a Service | Yes | Yes | | Free Trial Available | Yes | No | | Starting Paid Plan | $49/month, 10M Credits, 50 RPS | $125/month (minimum)** | | Enterprise plans and SLAs | Yes | Yes | | Customer Support | 24/7 Slack and Telegram support | 24/7 chat via dashboard | *As of July 2026. See [staking rewards](https://www.helius.dev/staking/rewards) for the latest data. **See Triton's pricing page for full plan details. ## Faster on the Solana RPC methods you call most Helius outperforms Triton on p95 latency across archival RPC calls (e.g., 6.0x faster getBlock calls) and heavy account-based calls (e.g., 3.5x faster getProgramAccounts calls). - **88.6 /100**: Helius's score vs. Triton (not yet ranked) ## #1 Solana infra provider for apps and traders Performance is won at the edges. We engineered a custom Solana stack, from our dedicated fiber backbone to our edge gateway and custom archival layer, to deliver the performance and reliability you deserve. - **Exclusive RPC methods**: Ergonomic calls like getTransfersByAddress for simpler queries and faster responses - **Industry-leading archival**: Custom RocksDB archival layer and exclusive RPC methods built for speed and scale - **Edge-first routing**: Custom edge gateway, global fiber backbone, and smart routing to return data faster - **Optimized for traders**: Preconfs, raw shreds, and optimized landing services to serve quants and serious firms - **Globally available**: Globally available, maximally redundant, and elastically scalable to support your traffic - **Build with agents**: Use our SDKs, MCP, CLI, and Claude Code plugin to ship Solana apps faster ## Which provider should you pick ### Choose Helius if... - You need free or entry-level plans with no minimum deposit - You are a quant, HFT, propAMM, searcher, or trading firm - You want the fastest RPCs, archival data, and streaming - You are an institution with bespoke reporting needs - You are an enterprise with strict compliance requirements ### Choose Triton if... - You need Sui and Monad support - You prefer Pay-As-You-Go (PAYG) billing - You are OK with monthly minimum deposits - You need Metis API and Titan API support - You want dedicated nodes and custom clusters ## How to migrate from Triton - **Get your Helius API key**: Create a project in your dashboard and get an API key - **Update your endpoints**: Replace your RPC, WSS, and other endpoints with Helius - **Test and deploy**: Validate performance on staging then cutover to prod ### Update RPC URL ```typescript // Before (Triton) const connection = new Connection( "https://YOUR_TRITON_ENDPOINT" ); // After (Helius) const connection = new Connection( "https://mainnet.helius-rpc.com/?api-key=YOUR_KEY" ); ``` [Get started](https://dashboard.helius.dev/signup) | [Read docs](https://www.helius.dev/docs) ## Trusted by Solana's best teams > "The Helius team makes building on Solana smoother and easier. They've done an amazing job at streamlining and removing complexity from app development on the network." — **Anatoly Yakovenko**, CO-FOUNDER & CEO, SOLANA > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana. They power a great portion of our infrastructure at Backpack." — **Armani Ferrante**, CO-FOUNDER & CEO, BACKPACK > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." — **Jonathan Levin**, CEO AND CO-FOUNDER, CHAINALYSIS ## Choose Helius Get started in seconds. No minimum deposit required. [Get started](https://dashboard.helius.dev/signup) --- ## Solana Infra and APIs for Decentralized Finance (DeFi) _Source: https://www.helius.dev/use-case/defi.md_ > Build the most performant Solana DeFi apps with real-time data streams, transaction landing services, enhanced WebSockets, and RPCs built for scale. **Use Cases** ## Solana infrastructure for DeFi and internet capital markets Power your DeFi stack on Solana’s most powerful RPCs, data streaming solutions, and transaction landing services. [Get started](https://dashboard.helius.dev/signup) ## Scalable infra powering permissionless finance ## How DFlow Uses LaserStream to Quote Solana's Best Prices See how DFlow, a leading DEX Aggregator on Solana eliminated engineering overhead, achieved 100% uptime, and recorded the single best month of swap volume in protocol history. [Read now](https://www.helius.dev/blog/dflow) ## Some of our partners Jupiter, Pump, Raydium, Axiom, Ellipsis, Pyth, Fomo, Meteora ## Your complete Solana DeFi development stack Everything you need to build world-class DEXs, lending platforms, Telegram bots, memecoin launchpads, and prediction markets, and more. - **Regions covered**: 7 - **SOL Staked**: 15M+ - **Uptime**: 99.99% - **Support**: 24/7 ## Trusted by Solana's best DeFi apps ## Keep your DeFi protocol's data fresh Power your app with ultra low latency streams of Solana blocks, accounts, and transactions so users always get the most accurate view of Solana DeFi. - Powered by ultra low latency shreds - Maximally redundant with automatic failover - 48-hour historical replay and auto reconnects > "Migrating was effortless. LaserStream was a drop-in replacement, and fully compatible with our Yellowstone consumption patterns." > — Jeff Delonge, CTO at DFlow [Learn more](https://www.helius.dev/laserstream) ## Transaction landing services built for DeFi Maximize your inclusion guarantees, reduce failed transactions, and give your customers an unforgettably smooth UX with Sender. - Route txns across every available high-speed pathway - Submit transactions through 7 regional endpoints - 50 TPS (default) and custom tip arrangements > "Sender consistently outperforms other services by landing my transactions almost instantly—most within a single slot." > — Alan, Trader [Learn more](https://www.helius.dev/sender) ## Reliable onchain alerts so you never miss a beat Track, monitor, and get notifications for accounts and transactions with full coverage for standard Solana WebSocket methods and Helius extensions. - Powered by LaserStream - Ideal for browser apps, dashboards, and wallets - Supports transactionSubscribe and accountSubscribe > "Helius is an essential piece of infrastructure. Their service is robust and reliable, the team is responsive and brilliant, and their attitude and dedication shows how much they care." > — Stepan Simkin, CEO and Co-founder at Squads Protocol [Learn more](https://www.helius.dev/solana-webhooks-websockets) ## RPCs engineered for Solana's speed and scale Experience the lowest-latency reads, and optimized archival methods to power all of your activity feeds, historical data, transaction receipts, and more. - Battle-tested to handle DeFi's biggest events - Cursor pagination and changedSinceSlot support - Earn [SOL rebates](https://www.helius.dev/docs/sending-transactions/backrun-rebates) from trades that create arbitrages [Learn more](https://www.helius.dev/solana-rpc-nodes) **See also:** - [Solana RPC Benchmarks](https://www.helius.dev/benchmarks): Compare RPC latency and reliability across providers ## Trusted by Solana's best DeFi apps > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." — **Nitesh Nath**, CO-FOUNDER & CEO, DFLOW > "The Helius team is GOATed. Besides providing best-in-class Solana RPCs, they've basically given us white-glove service for general Solana infrastructure advice & support. You can count on them to have your back." — **Richard Wu**, CO-FOUNDER, VECTOR.FUN > "Helius has been a game-changer for us with extremely reliable RPCs alongside Webhooks that have enabled a whole new set of use cases at a great price. Not to mention providing high-touch customer service for new features or any issues that we have." — **Luke Truitt**, CEO & CO-FOUNDER, LOOPSCALE > "Helius has been awesome. When daos.fun went viral, we needed to scale fast. Helius was the only provider that responded immediately on a Saturday night, and has been available 24/7 to help us with any issue." — **Baoskee**, CO-FOUNDER, DAOS.FUN ## Decentralized Finance, unleashed Get started in less than 10 seconds, no credit card required, or contact our sales team. [Get started](https://dashboard.helius.dev/signup) | [Contact us](https://www.helius.dev/contact) --- ## Solana infrastructure for Fintech 3.0 _Source: https://www.helius.dev/use-case/fintech.md_ > Learn how to use blockchain technology to build disruptive, next-gen financial products on Solana. **Use Cases** ## Solana infrastructure for Fintech 3.0 Leverage the power of blockchain technology to build disruptive, next-gen financial products on Solana. [Get started](https://dashboard.helius.dev/signup) ## Use Cases - **Cross-border Payments**: Reduce the settlement time and cost to process remittances. Send digital dollars anywhere in the world, 24/7. - **Neobanks**: Make saving, lending, and borrowing accessible to any person with a smartphone and internet connection. - **Stablecoin Accounts**: Enable businesses to use USD/EUR stablecoins for payroll, payouts, and for earning yield on idle cash. - **Wealth Management**: Give customers opportunities to invest in tokenized stocks, real world assets, and real-estate, and blue-chip digital assets. - **Buy Now, Pay Later**: Reduce the time and cost of traditional banking rails for financing short-term personal loans. - **Trade Finance**: Use blockchain payment rails to reduce counterparty risk and accelerate settlement times for supply chain payments. ## Global rails for open finance ## How DFlow Uses LaserStream to Quote Solana's Best Prices See how DFlow, a leading DEX Aggregator on Solana eliminated engineering overhead, achieved 100% uptime, and recorded the single best month of swap volume in protocol history. [Read now](https://www.helius.dev/blog/dflow) ## Some of our partners Coinbase, Fireblocks, Moonpay, Wormhole, Superstate, Altitude, BitGo, Brale ## Permissionless finance without borders Modernize your technology stack to create more accessible, open, and globally available financial applications. - **Regions covered**: 7 - **SOL Staked**: 15M+ - **Uptime**: 99.99% - **Support**: 24/7 ## Trusted by Solana's best teams ## Low latency, fault-tolerant data streaming via gRPC Keep stablecoin balances, investment portfolios, and transaction histories updated in real time. - Powerful SDKs and customizable filters - Highly redundant with automatic failover - 48-hour historical replay and auto reconnects > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." > — Nitesh Nath, CEO at DFlow [Learn more](https://www.helius.dev/laserstream) ## Transaction delivery for internet-scale Fintechs Predictably land stablecoin payments, deposits, and swaps through our top-staked validator even during periods of high onchain activity. - Sub-second confirmation latency - Bypass public queues for reliable delivery - Reduce failed transactions for improved UX > "The moment we switched our RPCs to Helius and started sending transactions through staked connections, all of our problems disappeared." > — Cody Lambert, Software Engineer at Brale [Learn more](https://www.helius.dev/staked-connections) ## Solana RPCs built for the future of finance Easily read onchain state, query [historical data](https://www.helius.dev/historical-data), and use WebSockets to subscribe to account updates. - Multiple regions for low latency - No single points of failure and automatic failover - JSON-RPC methods, WebSockets, and enhanced APIs [Learn more](https://www.helius.dev/solana-rpc-nodes) **See also:** - [Solana RPC Benchmarks](https://www.helius.dev/benchmarks): Compare RPC latency and reliability across providers ## Every stablecoin. Every asset. Every transaction. Give users maximum control over their tokens, visibility into their balances, and access to detailed account histories with simple APIs. - [NFT APIs](https://www.helius.dev/docs/das-api) for fast, reliable, and accurate querying - [Token APIs](https://www.helius.dev/solana-token-apis) for displaying balances and metadata - [Parsed Events API](https://www.helius.dev/parsed-data) for decoding wallet activity into readable instructions, transfers, and summaries > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana." > — Armani Ferrante, Co-founder and CEO at Backpack [Learn more](https://www.helius.dev/docs/das-api) ## Trusted by Solana's best teams > "At BitGo, we're focused on helping institutions unlock secure reward opportunities without adding operational overhead. Helius's validator is a natural fit for our Solana staking suite." — **Gbenga Omosuyi**, HEAD OF STRATEGIC PARTNERSHIPS > "Helius has been a game-changer for us with extremely reliable RPCs alongside Webhooks that have enabled a whole new set of use cases at a great price. Not to mention providing high-touch customer service for new features or any issues that we have." — **Luke Truitt**, CEO & CO-FOUNDER > "The engineers at Helius are top-notch go-getters that know that when your business is on the line, their business is on the line. They relish the opportunity for new problems to solve and aren't afraid to be at the cutting edge of Solana at all times." — **Jon Wong**, HEAD OF ECOSYSTEM ENGINEERING > "The Helius team has the best customer support in web3. Huma dapp is now working faster and more reliably on Solana." — **Erbil Karaman**, CO-FOUNDER > "As Solana activity continues to grow, Helius stands out as one of the leading Solana infrastructure providers, enabling our team to access reliable data that meets the demands of an enterprise-grade platform." — **Jonathan Levin**, CEO & CO-FOUNDER ## Fintech 3.0 runs on Solana Get started in less than 10 seconds, or contact our sales team to discuss enterprise contracts. [Get started](https://dashboard.helius.dev/signup) | [Contact us](https://www.helius.dev/contact) --- ## Integrate and scale your Solana wallet _Source: https://www.helius.dev/use-case/wallets.md_ > Build the most performant Solana wallet with flexible token and NFT APIs, archival data, real-time data streams, and transaction landing services. **Use Cases** ## Integrate and scale your Solana wallet Give Solana users a wallet experience that they love and trust by building with a stack purpose-built to deliver unmatched reliability, scale, and speed. [Get started](https://dashboard.helius.dev/signup) ## Ensure your wallet stays up during Solana's largest onchain events ## How DFlow Uses LaserStream to Quote Solana's Best Prices See how DFlow, a leading DEX Aggregator on Solana eliminated engineering overhead, achieved 100% uptime, and recorded the single best month of swap volume in protocol history. [Read now](https://www.helius.dev/blog/dflow) ## Powering leading wallets Backpack, Phantom, Solflare, Squads, Ledger, MetaMask, Exodus, Trust ## Your complete Solana wallet development stack Everything you need to build world-class hardware wallets, embedded wallets, or wallets for browsers and mobile experiences. - **Regions covered**: 7 - **SOL staked**: 15M+ - **Uptime**: 99.99% - **Support**: 24/7 ## Trusted by Solana's best wallets ## Update your wallet data in real-time Power your wallet with ultra low latency streams of Solana blocks, accounts, and transactions so users always see the freshest Solana state. - Powered by ultra low latency shreds - Maximally redundant with automatic failover - 48-hour historical replay and auto reconnects > "LaserStream was a seamless drop-in replacement for Geyser. It integrated perfectly with Jupiter infra and performed impressively fast." > — Aryan, Co-founder at SendAI [Learn more](https://www.helius.dev/laserstream) ## Reliably land in-wallet swaps and sends at scale No matter how busy Solana gets, predictably land your user's deposits, swaps, and transfers by submitting transactions to our top-staked validator. - Bypass public queues for reliable delivery - Reduce failed transactions for improved UX - Earn [SOL rebates](https://www.helius.dev/docs/sending-transactions/backrun-rebates) from trades that create arbitrages > "Thanks to [Helius's] support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." > — Jorge Valdeiglesias, Staff Software Engineer at Phantom [Learn more](https://www.helius.dev/staked-connections) ## Power your wallets with industry-leading RPCs Get token accounts, token balances, and [historical data](https://www.helius.dev/historical-data) for all of your users, and reliably simulate, send, and monitor the status of transactions sent via RPC. - Battle-tested to handle wallet-level scale - Highly redundant and SOC II Type 2 certified - Helius exclusive methods with cursor-based pagination > "RPC side, Helius has been incredibly responsive. Working with bleeding edge tech like NFT compression, this has been invaluable." > — Noah Prince, Head of Protocol Engineering at Helium [Learn more](https://www.helius.dev/solana-rpc-nodes) **See also:** - [Solana RPC Benchmarks](https://www.helius.dev/benchmarks): Compare RPC latency and reliability across providers ## Every token. Every NFT. Every transaction. Build a feature-rich Solana wallet users truly love with powerful APIs to manage tokens, transaction histories, and estimating priority fees. - [NFT APIs](https://www.helius.dev/docs/das-api) for fast, reliable, and accurate querying - [Token APIs](https://www.helius.dev/solana-token-apis) for displaying balances and metadata - [Parsed Events API](https://www.helius.dev/parsed-data) for decoding wallet activity into readable instructions, transfers, and summaries > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana." > — Armani Ferrante, Co-founder and CEO, Backpack [Learn more](https://www.helius.dev/docs/das-api) ## Trusted by Solana's best wallets > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM > "Helius is super fast, reliable, and I'd recommend them to anyone looking for the best developer experience on Solana. They power a great portion of our infrastructure at Backpack." — **Armani Ferrante**, CEO AND CO-FOUNDER, BACKPACK > "The Helius team is the GOAT. They ship fast, intake product feedback overnight, and power a great deal of Crossmint infrastructure. A big percentage of Crossmint products couldn't exist without Helius." — **Alfonso Gomez Manas**, CO-FOUNDER, CROSSMINT > "Helius is an absolutely essential piece of infrastructure, their service is robust and reliable, the team is responsive and brilliant, their attitude and dedication shows how much they care. They are passionately aligned with the success of their customers." — **Stepan Simkin**, CEO & CO-FOUNDER, SQUADS > "Helius runs a dedicated gRPC plugin that we use for large, real-time data consumption. The performance and support has been better than anything we've seen in the industry." — **Tanner Philp**, COO, FLIPCASH > "Helius's RPC service delivers same-slot latency with ready-to-use frontend links that integrate seamlessly into our app—complete with smart rate limiting to avoid any overages, saving us countless dev hours, and protecting against unexpected expenses." — **Bill Papas**, FOUNDER, UNRUGGABLE ## Build a world-class Solana wallet Get started in less than 10 seconds, or contact our sales team. [Get started](https://dashboard.helius.dev/signup) | [Contact us](https://www.helius.dev/contact) --- ## Solana infra purpose-built for exchanges _Source: https://www.helius.dev/use-case/exchanges.md_ > Build the most performant cryptocurrency exchange for listing, trading, and staking Solana tokens including real-time price data, staked connections, and RPCs. **Use Cases** ## Solana infra purpose-built for exchanges Everything you need to integrate Solana and scale your exchange — from handling trades to transfers, staking, and portfolio dashboards. [Get started](https://dashboard.helius.dev/signup) ## Global, enterprise-grade exchange infra ## How DFlow Uses LaserStream to Quote Solana's Best Prices See how DFlow, a leading DEX Aggregator on Solana eliminated engineering overhead, achieved 100% uptime, and recorded the single best month of swap volume in protocol history. [Read now](https://www.helius.dev/blog/dflow) ## Some of our partners Coinbase, Binance, OKX, Bybit, Crypto.com, MEXC, Bitget, Bittrue ## Run your exchange at Solana speed Ensure every trader has a great experience onboarding to Solana, trading Solana tokens, and staking SOL without worrying about downtime or congestion. - **Regions covered**: 7 - **SOL Staked**: 15M+ - **Uptime**: 99.99% - **Support**: 24/7 ## Trusted by Solana's best teams ## Feed real-time onchain data to your exchange Power your exchange with ultra low latency onchain transaction, account, and block data using LaserStream — the fastest, most fault-tolerant gRPC data streaming solution. - Powered by ultra low latency shreds - Maximally redundant with automatic failover - 48-hour historical replay and auto reconnects > "To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." > — Nitesh Nath, CEO at DFlow [Learn more](https://www.helius.dev/laserstream) ## Reliably land user transactions at scale Guarantee deposits, withdrawals, and trades land onchain by sending transactions via staked endpoints, your priority lane for landing transactions quickly. - Bypass public queues for reliable delivery - Reduce failed transactions for improved UX - Earn [SOL rebates](https://www.helius.dev/docs/sending-transactions/backrun-rebates) from trades that create arbitrages > "Helius' seamless infrastructure management ensures everything runs smoothly, allowing us to focus on building and scaling our trading operations without worrying about the details of running Solana nodes." > — Jeremy De Groodt, Co-founder and CTO at Keyrock [Learn more](https://www.helius.dev/staked-connections) ## Offer SOL staking to your exchange customers Offer your exchange users an easy way to stake SOL directly in your app. Earn block rewards and set your own commission rate to earn more rewards. - SOC II Type 2-compliant infrastructure - Supported by BitGo and other custodians - Managed 24/7 by Solana-native engineers [Learn more](https://www.helius.dev/validator-as-a-service) **See also:** - [Validator](https://www.helius.dev/validator): 0% fees. 100% inflation rewards. 100% MEV rewards. ## Power your exchange with industry-leading RPCs Get token accounts and token balances for all of your users, and reliably simulate, send, and monitor the status of transactions sent via RPC. - Battle-tested to handle exchange-level scale - Highly redundant and SOC II Type 2 certified - Industry-leading transaction-sending success rates [Learn more](https://www.helius.dev/solana-rpc-nodes) **See also:** - [Solana RPC Benchmarks](https://www.helius.dev/benchmarks): Compare RPC latency and reliability across providers ## Trusted by Solana's best teams > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." — **Nitesh Nath**, CO-FOUNDER AND CEO > "Having personally built our own in-house indexing and data pipelines at Zeta, I know how much of a headache it is for new teams. Being able to save countless hours of data engineering work and costly AWS bills is a big advantage for us." — **Tristan Frizza**, FOUNDER & CEO, ZETA MARKETS > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM > "The engineers at Helius are top-notch go-getters that know that when your business is on the line, their business is on the line. They relish the opportunity for new problems to solve and aren't afraid to be at the cutting edge of Solana at all times." — **Jon Wong**, HEAD OF ECOSYSTEM ENGINEERING, SOLANA FOUNDATION ## Elevate your exchange Get started in less than 10 seconds, or contact our sales team. [Get started](https://dashboard.helius.dev/signup) | [Contact us](https://www.helius.dev/contact) --- ## Trade and make any market with an edge _Source: https://www.helius.dev/use-case/trading.md_ > Build the most performant Solana trading stack with ultra low-latency data feeds, and transaction landing services. **Use Cases** ## Trade and make any market with an edge Win more trades by building a unified trading system that combines the lowest-latency reads of LaserStream with the fastest transaction landing services of Sender. [Get started](https://dashboard.helius.dev/signup) ## Purpose-built networks for 24/7 connectivity ## How DFlow Uses LaserStream to Quote Solana's Best Prices See how DFlow, a leading DEX Aggregator on Solana eliminated engineering overhead, achieved 100% uptime, and recorded the single best month of swap volume in protocol history. [Read now](https://www.helius.dev/blog/dflow) ## Some of our partners Wintermute, Jump Crypto, Galaxy, Ergonia, Tokka Labs, Selini Capital, Ellipsis Labs, Pyth - **Regional endpoints**: 7 - **SOL Staked**: 15M+ - **Uptime**: 99.99% - **Support**: 24/7 ## Trusted by Solana's best traders ## See transactions the moment they're scheduled Preconfirmations stream transactions the instant a validator's scheduler commits to executing them. It's the earliest signal you can react to. - The lowest-latency transaction signal Helius offers - Streamed over a preconfSubscribe WebSocket - Available on all paid plans [Learn more](https://www.helius.dev/preconfirmations) **See also:** - [Raw Shred Delivery](https://www.helius.dev/shreds): Stream raw, unprocessed shreds ## Reliably land trades in any market conditions Land transactions everywhere, every time with our ULL transaction sending service. No API credits. Pay per send with a SOL tip. Built for traders. - **Min. SOL tip**: 0.001 - **Min. SOL tip**: 0.000005 - Route txns across every available high-speed pathway - Submit transactions through 7 regional endpoints - 50 TPS (default) and custom tip arrangements [Learn more](https://www.helius.dev/sender) ## Stream trading data at the speed of light Power your trading engine with LaserStream — the fastest, most fault-tolerant gRPC streaming solution. No dedicated nodes required. - Powered by ultra low latency shreds - Maximally redundant with automatic failover - 48-hour historical replay and auto reconnects > "To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." > — Nitesh Nath, CEO at DFlow [Learn more](https://www.helius.dev/laserstream) ## Trusted by Solana's best traders > "The number one thing we care about is safety for users. To give traders the best price and tightest spreads, we depend on LaserStream to feed our price engine with the freshest, fastest onchain data." — **Nitesh Nath**, CO-FOUNDER & CEO, DFLOW > "Helius has been instrumental in kickstarting our Pythnet operations. Their seamless infrastructure management ensures everything runs smoothly, allowing us to focus on building and scaling our trading operations without worrying about the details of running Solana nodes." — **Jeremy De Groodt**, CO-FOUNDER & CTO, KEYROCK > "The Helius team's deep technical expertise in Solana and node management was absolutely critical during one of our most challenging and busiest days. Thanks to their support, we handled extreme congestion and enabled our users to complete more than 10 million transactions in just one day." — **Jorge Valdeiglesias**, STAFF SOFTWARE ENGINEER, PHANTOM > "Having personally built our own in-house indexing and data pipelines at Zeta, I know how much of a headache it is for new teams. Being able to save countless hours of data engineering work and costly AWS bills is a big advantage for us." — **Tristan Frizza**, FOUNDER & CEO, ZETA MARKETS ## Trade with an edge Get started in less than 10 seconds, no credit card required, or contact sales to explore enterprise plans. [Get started](https://dashboard.helius.dev/signup) | [Contact us](https://www.helius.dev/contact) --- ## Blog Index _Source: https://www.helius.dev/blog/llms.txt_ > Research, tutorials, and updates from the Helius team. The Helius blog covers Solana development, infrastructure, and ecosystem news. Posts are listed newest-first; each entry links to the markdown variant suitable for direct agent consumption. ## Posts - [Introducing Solana Privacy Rings](https://www.helius.dev/blog/solana-privacy-rings.md): Solana Privacy Rings enable programmable, fully onchain privacy solutions on Solana. Learn how it works and how to get started. - [Introducing the Parsed Events Scan API](https://www.helius.dev/blog/parsed-events-scan.md): Scan any wallet on Solana using server-side filters for programs, instructions, token mint addresses, and only pay for what you scan. - [Agave 4.4 Update: All You Need to Know](https://www.helius.dev/blog/agave-v4-4.md): A roundup of the most important features and performance upgrades in the Solana Agave 4.4 validator client release. - [The Price of Cheap Writes: How does RocksDB read?](https://www.helius.dev/blog/rocksdb-read-path.md): RocksDB reads newest to oldest, stopping at the first version it finds. Learn how bloom filters, the block cache, and prefix seeks keep that search fast. - [Agave 4.3 Update: All You Need to Know](https://www.helius.dev/blog/agave-v4-3.md): A roundup of the most important changes in the Solana Agave 4.3 validator client release, headlined by Alpenglow replacing TowerBFT with Votor. - [Solana Transaction Versioning: Legacy, v0 and v1](https://www.helius.dev/blog/solana-transaction-versions.md): How Solana's three transaction formats differ on the wire: legacy, v0 with Address Lookup Tables, and v1's 4,096-byte redesign with native resource configuration. - [Introducing the Parsed Events API and Parsed Streams](https://www.helius.dev/blog/parsed-events-and-streams.md): Get fully parsed transactions for over 3,600 Solana programs with the Parsed Events API and Parsed Streams. - [Agave 4.2: The Migration Checklist](https://www.helius.dev/blog/agave-4-2-migration-checklist.md): Learn about Agave 4.2 breaking changes and how to verify your integrations before mainnet feature gates activate. - [What is an LSM Tree? The Log-Structured Merge Tree Explained](https://www.helius.dev/blog/lsm-tree-explained.md): A complete walkthrough of the LSM tree and its write path—memtable, WAL, and SST files—including how to trace a single write on your own machine - [Agave 4.2 Update: All You Need to Know](https://www.helius.dev/blog/agave-v4-2.md): A roundup of the most important features and performance upgrades in the Solana Agave 4.2 validator client release. - [What are Preconfirmations (Preconfs) on Solana?](https://www.helius.dev/blog/solana-preconfirmations.md): Preconfirmations (preconfs) are the earliest transaction signal on Solana, streamed the moment a leader executes a transaction. Learn how they work - [Setting Up Subscriptions and Recurring Payments on Solana](https://www.helius.dev/blog/solana-subscriptions-recurring-payments.md): Build onchain subscriptions on Solana with Helius. Learn how to create plans, collect payments, and manage renewals. - [What is RocksDB? The Embedded Key-Value Store](https://www.helius.dev/blog/what-is-rocksdb.md): RocksDB is an embeddable, persistent key-value store optimized for fast storage. Learn how it works and how it’s used at a global scale - [Agave 4.1 Update: All You Need to Know](https://www.helius.dev/blog/agave-v4-1.md): A roundup of the most important features and performance upgrades in the Solana Agave 4.1 validator client release. - [Reclaiming Opacity: The Imperative for Privacy in Crypto](https://www.helius.dev/blog/why-crypto-needs-privacy.md): Privacy is opacity—the right to live unindexed. This was forgotten while popularizing crypto. We need to build, run, and use more privacy solutions - [SIMD-550: Why Solana Should Double Disinflation](https://www.helius.dev/blog/simd-550-solana-disinflation.md): A deep dive into Solana Improvement Document 550, which seeks to reduce Solana’s emissions schedule by doubling the disinflation rate - [Helius acquires Light to build the canonical privacy layer for Solana](https://www.helius.dev/blog/light-protocol-acquisition.md): Helius is acquiring the Solana privacy startup, Light Protocol, to build an onchain privacy solution. - [From ClickHouse to RocksDB: How We Rebuilt Solana’s Archival Layer](https://www.helius.dev/blog/migrating-from-clickhouse-to-rocksdb.md): How and why Helius rebuilt Solana's archival layer on RocksDB instead of ClickHouse, cutting storage from 330TB to 190TB and slashing query latency - [Agave 4.0 Update: All You Need to Know](https://www.helius.dev/blog/agave-v4-0.md): A roundup of the most important features and performance upgrades in the Solana Agave 4.0 validator client release. - [getTransfersByAddress: Parsed Solana Transfer History in 1 Call](https://www.helius.dev/blog/introducing-gettransfersbyaddress.md): getTransfersByAddress is a new Helius-exclusive Solana RPC method that returns parsed, human-readable token and SOL transfer records for any wallet address. - [Helius Joins the Solana Research Institute as Founding Member](https://www.helius.dev/blog/solana-research-institute.md): We joined the Solana Research Institute as a founding member to publish and promote rigorous, institutional-grade research about the Solana network. - [Constellation: A Proposal For MCP on Solana](https://www.helius.dev/blog/constellation.md): Constellation is Anza's proposal to implement Multiple Concurrent Proposers (MCP) on Solana. Learn how it works, the problems it solves, and open questions. - [LaserStream Now Powers All Helius WebSockets](https://www.helius.dev/blog/laserstream-websockets.md): All WebSocket streaming is now powered by LaserStream infrastructure, delivering up to 200ms faster event delivery for Standard Solana WSS methods. - [Helius Joins Solana Developer Platform](https://www.helius.dev/blog/solana-developer-platform.md): Learn how Helius is helping financial institutions and enterprises build applications on Solana. - [Helius for Agents](https://www.helius.dev/blog/helius-for-agents.md): One-shot anything on Solana with the Helius Claude Code Plugin, MCP Server with 60+ tools, CLI with 95+ commands, skills, and agent-friendly SDKs. - [Introducing Gatekeeper: The Helius Edge Gateway](https://www.helius.dev/blog/introducing-gatekeeper.md): Gatekeeper is a unified, low-latency, global edge network that improves response times tens to hundreds of ms faster. Supports RPC, WSS, DAS, and more. - [Agave 3.1 Update: All You Need to Know](https://www.helius.dev/blog/agave-v3-1.md): A roundup of the most important features and performance upgrades in the Solana Agave 3.0 validator client release. - [Introducing Token Account Filters for gTFA](https://www.helius.dev/blog/solana-token-accounts-history.md): Get the complete transaction history for a Solana wallet’s token accounts with the new tokenAccounts filter for the getTransactionsForAddress RPC method. - [The Helius Manifesto](https://www.helius.dev/blog/manifesto.md): Helius’ mission is to increase the economic potential of the world’s developers. And we believe this is only possible with crypto rails. - [What Would Solana Need to Change to Become Quantum Ready?](https://www.helius.dev/blog/solana-post-quantum-cryptography.md): Post-quantum pathways for Solana, examining potential protocol and signature upgrades that could strengthen security. - [What is the Solana Virtual Machine (SVM)?](https://www.helius.dev/blog/solana-virtual-machine.md): Learn how the Solana Virtual Machine (SVM) works: from Rust source compiling through LLVM to sBPF bytecode, to how the SVM executes transactions. - [Top 13 Solana Block Explorers (2026)](https://www.helius.dev/blog/top-solana-block-explorers.md): Discover 13 of the best block explorers on Solana, including Orb, Jito's MEV bundle explorer, and the original explorer maintained by the Solana Foundation. - [Introducing Orb: Solana's New Block Explorer](https://www.helius.dev/blog/orb-block-explorer.md): Orb is a fast, human-readable Solana block explorer built by Helius on state-of-the-art archival infrastructure. Discover its powerful new features and design. - [16 U.S. Solana Spot ETFs: Approvals, Fees, Tickers, S1s](https://www.helius.dev/blog/solana-etfs.md): After months of growing investor excitement, U.S.-listed Solana Spot ETFs are launching marking a major milestone for Solana's presence in traditional markets. - [getTransactionsForAddress and up to 10x Faster Archival Data](https://www.helius.dev/blog/introducing-gettransactionsforaddress.md): getTransactionsForAddress is a new Solana RPC method for querying historical data with powerful features, including reverse search, time-based filtering, and pagination. - [Bitwise Selects Helius as Exclusive SOL Staking Provider](https://www.helius.dev/blog/bitwise-solana-etf.md): Bitwise selects Helius as the exclusive SOL staking provider to run their Bitwise Onchain Solutions validator for the Solana Staking ETF (NYSE: BSOL). - [High-Performance Solana Streaming with LaserStream SDKs ](https://www.helius.dev/blog/laserstream-sdks.md): Learn how the LaserStream SDK improves Solana gRPC data streaming throughput 40x from 30 MB/s to 1.3GB/s. - [The Solana Company Selects Helius as SOL Staking Provider](https://www.helius.dev/blog/the-solana-company-selects-helius-as-sol-staking-provider.md): The Solana Company, a Solana Digital Asset Treasury company, backed by Pantera Capital and Summer Capital selects Helius as a non-custodial staking provider. - [Agave 3.0 Update: All You Need to Know](https://www.helius.dev/blog/agave-v3-0.md): A roundup of the most important features and performance upgrades in the Solana Agave 3.0 validator client release. - [Introducing: Next-Generation Enhanced WebSockets](https://www.helius.dev/blog/introducing-next-generation-enhanced-websockets.md): Enhanced WebSockets are now powered by the same infra that powers LaserStream, our next-generation gRPC streaming service built for speed and fault-tolerance. - [The Rise of Solana Digital Asset Treasury Companies](https://www.helius.dev/blog/solana-digital-asset-treasury-companies.md): Explore Solana’s digital asset treasury firms: who’s raising, how much SOL they hold, and their impact on the ecosystem. - [Rockets, Quantum Threats, Zeros and Ones: Dean Little on Forging Solana's Truth](https://www.helius.dev/blog/dean-little.md): An interview exploring Dean's beginnings, cryptographic innovations, thoughts on assembly, and his educational work at Blueshift - [Achieving Zero-Slot Execution with Sender and LaserStream](https://www.helius.dev/blog/zero-slot.md): Learn how to achieve zero-slot execution with Sender and LaserStream, a unified workflow that turns signals into profitable opportunities - [P-Token: Solana’s Next Big Efficiency Unlock](https://www.helius.dev/blog/solana-p-token.md): P-token is a new drop-in replacement for the SPL Token program that delivers an impressive 95%+ reduction in compute unit consumption. - [How to Write Solana Programs with SBPF Assembly](https://www.helius.dev/blog/sbpf-assembly.md): Learn about sBPF's virtual machine architecture, instruction set, and memory model. Then follow a simple SBPF Assembly tutorial to deploy your first program. - [Solana’s Proprietary AMM Revolution](https://www.helius.dev/blog/solanas-proprietary-amm-revolution.md): Learn all about proprietary AMMs, a new market-making primitive pioneered on Solana - [Hardware as Ideology: An Interview with Austin Federa](https://www.helius.dev/blog/hardware-as-ideology-austin-federa.md): An interview with Austin Federa, co-founder of DoubleZero, on hardware, Solana, and creating a new Internet for the next era of blockchains - [Winning the Millisecond Game: Shreds, LaserStream, and the Edge of Solana](https://www.helius.dev/blog/solana-shreds.md): Learn how Solana shreds work, compare shred delivery latency across Solana validators and data streaming solutions, and see how LaserStream gives you an edge. - [Solana Breakpoint 2025 Giveaway](https://www.helius.dev/blog/solana-breakpoint-2025-giveaway.md): Have you made significant contributions to OSS development on Solana? Apply for your chance to win a free trip to Solana Breakpoint 2025 in Abu Dhabi. - [How DFlow Uses LaserStream to Quote Solana's Best Prices](https://www.helius.dev/blog/dflow.md): Learn how DFlow uses LaserStream to offer Solana market makers the best prices, tightest spreads, and lowest latency routes.  - [Bringing Slashing to Solana](https://www.helius.dev/blog/bringing-slashing-to-solana.md): Programmatic slashing is making its way to Solana. Discover what is being proposed and how it will impact the network. - [Block Assembly Marketplace (BAM)](https://www.helius.dev/blog/block-assembly-marketplace-bam.md): Jito’s BAM is the most ambitious overhaul of Solana’s block construction yet, introducing private, programmable, and provably fair transaction sequencing. - [On-Chain Proof Storage in DePIN: Sector Patterns, Drivers, and the Coming Wave of Adoption](https://www.helius.dev/blog/depin-proof-storage.md): Learn why proof storage matters for data aggregation and service-based DePINs. Compare frameworks, read case studies, and decide which method is right for you. - [Agave v2.3 Update: All You Need to Know](https://www.helius.dev/blog/agave-v23-update--all-you-need-to-know.md): Catch all the key release cycle features and optimizations to watch out for with the Solana Agave 2.3 client update. - [How to Write Solana Programs with Steel](https://www.helius.dev/blog/steel.md): Steel is a modular, lightweight development framework for writing smart, performant Solana programs. Learn how it works and how to create a token. - [Engineering Velocity: Inside Anza’s Performance Team with Alessandro Decina](https://www.helius.dev/blog/solana-performance-engineering.md): An interview with Alessandro Decina, who leads Anza's performance team, on making the fastest blockchain in existence even faster - [How to Build Solana Apps with Gill](https://www.helius.dev/blog/gill.md): Learn how to develop Solana apps with Gill, a modern and developer-friendly JavaScript/TypeScript client library for interacting with the Solana blockchain. - [Internet Capital Markets](https://www.helius.dev/blog/internet-capital-markets.md): Internet Capital Markets presents a reimagining of finance, radically reducing the barriers to issuing and owning assets. - [Introducing Helius’s Solana Devnet Faucet](https://www.helius.dev/blog/solana-faucet.md): Access the Solana Devnet faucet in your dashboard. Claim Devnet SOL through the UI or request an airdrop through the Solana CLI. - [Staking with Helius and hSOL are Now Supported on BitGo](https://www.helius.dev/blog/bitgo.md): BitGo customers can now maximize their institutional staking rewards on Solana by delegating stake to Helius’s 0% commission, 0% fee validator. - [Solana Ecosystem Report (H1 2025)](https://www.helius.dev/blog/solana-ecosystem-report-h1-2025.md): A comprehensive analysis of Solana's current state as of mid-2025, examining its technical foundations, economics, and key ecosystem developments - [How to Build Solana Programs with Pinocchio](https://www.helius.dev/blog/pinocchio.md): Develop Solana programs with Pinocchio. Learn how Pinocchio works and compare Pinocchio vs. Anchor vs. Steel. Includes a tutorial on creating a Solana token. - [Solana Passkeys: The Future of Crypto Wallet UX](https://www.helius.dev/blog/solana-passkeys.md): Learn how to use passkeys on Solana to accelerate onboarding, eliminate the risk of losing seed phrases, and improve wallet UX. - [Real World Assets on Solana: A Comprehensive Overview](https://www.helius.dev/blog/solana-real-world-assets.md): An overview of the Solana real world asset landscape, showcasing the growing diversity of RWA offerings and their practical applications. - [Introducing LaserStream: Next-Gen Solana Data Streaming](https://www.helius.dev/blog/introducing-laserstream.md): Stream Solana blocks, accounts and transactions faster. LaserStream is a scalable, low-latency, and fault-tolerant alternative to Yellowstone gRPC and WebSockets. - [Introducing the Builder Series Guest Blog Program](https://www.helius.dev/blog/guest-blog.md): Launch products. Educate developers. Build authority within the Solana ecosystem. Learn how to pitch articles and get featured on the Helius blog. - [How to Build Mobile Apps with Send’s Solana AppKit](https://www.helius.dev/blog/solana-appkit.md): Introducing the Solana AppKit — an open-source React Native toolkit for building iOS and Android apps on Solana, with 18+ protocol integrations. - [Helius Receives SOC 2 Type II Certification](https://www.helius.dev/blog/soc2.md): Helius is now SOC 2 Type II certified. The audit was performed by Sensiba LLP. Visit our Trust Center to request a copy of our audit. - [Solana Consulting and Advisory Services](https://www.helius.dev/blog/solana-consulting.md): Consult with Helius before building on the Solana blockchain. Explore Solana advisory, Solana development services, and Solana launch strategies. - [Frictionless and secure UX: the tech stack onboarding millions of users to Solana](https://www.helius.dev/blog/web3-ux.md): Learn how to build seamless onchain user experiences with Privy's embedded wallets, gasless transactions, onramps, and native bridging. - [Solana Staking Taxes and Reporting Guide](https://www.helius.dev/blog/solana-staking-taxes.md): Learn about how Solana staking rewards are taxed, taxable events, tax advantages of LSTs, managing tax liabilities, reporting staking income, and tax software. - [Solana’s Stablecoin Landscape](https://www.helius.dev/blog/solanas-stablecoin-landscape.md): We explore the stablecoin ecosystem on Solana, tracking adoption, highlighting the growing variety of tokens, and examining real-world use cases. - [Solana for Enterprise: Reasons and Use Cases](https://www.helius.dev/blog/solana-for-enterprise.md): Learn why Solana is a strong contender for enterprise adoption, as well as why both new and established projects are choosing Solana - [Alpenglow: Solana's Great Consensus Rewrite](https://www.helius.dev/blog/alpenglow.md): Learn about Alpenglow, Solana's consensus rewrite, how it works, its performance, security and fault-tolerance, impact, risks and open questions - [Solana Hacks, Bugs, and Exploits: A Complete History](https://www.helius.dev/blog/solana-hacks.md): Explore the cause, impact, and fix for 35+ Solana application exploits, supply chain attacks, network incidents, and protocol vulnerabilities. - [Announcing the [REDACTED] Hackathon Winners](https://www.helius.dev/blog/redacted-hackathon-winners.md): $175,000 in prizes. 38 bounties. 900+ submissions. Meet the winners of the 2025 [REDACTED] Hackathon for analysts, security researchers, and onchain sleuths - [Stablecoin Payments Guide for Fintechs & Financial Institutions](https://www.helius.dev/blog/stablecoin-payments.md): Digital dollars are reshaping the global payments market. Explore stablecoin use cases, benefits, issuers, and the best blockchains for stablecoin apps. - [What are Solana Commitment Levels?](https://www.helius.dev/blog/solana-commitment-levels.md): Understand Solana commitment levels. Processed, Confirmed, Finalized. Differences, use cases, and performance impacts. - [Introducing Surfpool: A Solana Devnet Alternative](https://www.helius.dev/blog/surfpool.md): Learn how Surfpool and Infrastructure as Code (IaC) is improving the way Solana developers test and deploy programs on Devnet and Mainnet-beta. - [Agave v2.2 Update: All You Need to Know](https://www.helius.dev/blog/agave-v22-update--all-you-need-to-know.md): A roundup of the most important features and performance upgrades in the Solana Agave 2.2 validator client release. - [Building Permissioned Blockchains with Solana Permissioned Environments](https://www.helius.dev/blog/solana-permissioned-blockchains.md): This article dives into Solana’s ecosystem of private appchains, tailored for enterprise-grade performance and regulatory compliance. - [Introducing Helius Validator-as-a-Service](https://www.helius.dev/blog/introducing-validator-as-a-service.md): Launch an institutional-grade, white label Solana validator with Helius. Maximize your rewards. Leverage the experience of Solana's most trusted node provider. - [At The Edge Of Determinism: Transaction Lifecycle in Solana Sealevel and Sui Object Runtime](https://www.helius.dev/blog/solana-vs-sui-transaction-lifecycle.md): Learn how Solana transactions are created, submitted, propagated, executed, and validated compared to Sui's object runtime. - [Confidential Balances: Empowering Confidentiality in the Solana Ecosystem](https://www.helius.dev/blog/confidential-balances.md): Introducing Confidential Balances — new layers of confidentiality for asset owners and token issuers without sacrificing regulatory compliance. - [How to Build a Solana Data Dashboard with Dune](https://www.helius.dev/blog/how-to-build-a-solana-data-dashboard-with-dune.md): Learn how to build a comprehensive Solana dashboard, leveraging real-time metrics, historical trends, and decoded program data. - [Solana Governance: A Comprehensive Analysis](https://www.helius.dev/blog/solana-governance--a-comprehensive-analysis.md): This report provides a detailed overview of Solana's governance framework, tracing its evolution and explaining how decisions are proposed, evaluated, and implemented. - [Embedded MPC Wallets for Payments Apps on Solana](https://www.helius.dev/blog/solana-mpc-wallet.md): Learn how embedded MPC wallets work on Solana. Get step-by-step instructions for integrating them in your stablecoin application with Portal. - [What are Solana Smart Wallets? Comparison & Implementation Guide](https://www.helius.dev/blog/solana-smart-wallets.md): Learn how Solana smart wallets work, compare different embedded wallet providers, and follow our step-by-step guide to integrate them in your app. - [Announcing the [REDACTED] Hackathon](https://www.helius.dev/blog/redacted-hackathon.md): Compete for over $150,000 in bounties from Solana's leading data, forensics, and security companies. Submissions open April 1st, 2025. - [SIMD-228: A Critical Analysis](https://www.helius.dev/blog/simd-228.md): This report analyzes SIMD-228: Market-Based Emission Mechanism, assessing its potential effects and evaluating key arguments for and against. - [Solana Arithmetic: Best Practices for Building Financial Apps](https://www.helius.dev/blog/solana-arithmetic.md): Learn how to safely perform mathematical operations on Solana tokens, including calculating interest, rounding numbers, and more. - [What are Solana PDAs? Explanation & Examples (2026)](https://www.helius.dev/blog/solana-pda.md): Learn how Program Derived Addresses (PDAs) work, and review four examples of how they are used to store data for Solana programs (smart contracts). - [A Complete History of Solana Outages: Causes, Fixes, and Lessons Learnt](https://www.helius.dev/blog/solana-outages-complete-history.md): This article analyzes every Solana outage incident in detail, examining the root causes, triggering events, and the measures taken to resolve them. - [Analyzing Solana On-chain Data: Tools & Dashboards](https://www.helius.dev/blog/solana-data-tools.md): This guide gives new analysts an overview of tools for accessing Solana data including tools for streaming data, historical analysis, and on-chain metrics. - [Introducing Kite: the Modern Solana TypeScript Framework](https://www.helius.dev/blog/kite-solana-typescript-framework.md): Kite leverages the speed and elegance of Solana web3.js version 2 but allows you to do most common Solana tasks in a single function. - [Agave v2.1 Update: All You Need to Know](https://www.helius.dev/blog/agave-v21-update-all-you-need-to-know.md): A summary of all the key release cycle features and optimizations to watch out for with the Solana Agave 2.1 client update. - [How to Turn Your Idea into a Solana Program (Smart Contract)](https://www.helius.dev/blog/how-to-turn-your-idea-into-a-solana-program-smart-contract.md): We’ll use a Polymarket-style prediction market on Solana to show how to transform concepts into accounts, store tokens, and optimize performance. - [How to Build a Secure AI Agent on Solana](https://www.helius.dev/blog/how-to-build-a-secure-ai-agent-on-solana.md): Learn how to build an AI Agent that can access its own Solana wallet without compromising security using Turnkey's policy-controlled credentials. - [Solana App Onboarding: The Case for Embedded Wallets](https://www.helius.dev/blog/solana-embedded-wallets.md): Learn how to add embedded wallets to your Solana application and quickly onboard new users who may not already have a self-custodial wallet. - [The Cheapest Way to Airdrop Solana Tokens](https://www.helius.dev/blog/solana-airdrop.md): Discover how to send Solana airdrops at scale without draining your budget. This guide compares the traditional approach, details where costs come from, and shows how zero-knowledge (ZK) compression cuts fees by over 95%. - [$TRUMP’s Historic Weekend on Solana: Records, Trends, and Insights](https://www.helius.dev/blog/trump-solana-memecoin-records-trends-insights.md): January 18th and 19th, 2025 was a historic weekend for Solana. Discover the record-breaking activity, trends, and insights. - [How to Use AI to Build Solana Apps](https://www.helius.dev/blog/how-to-use-ai-to-build-solana-apps.md): Learn how to use AI programming tools to build Solana applications. Discover tips and engineering prompts to accelerate development cycles. - [The Truth about Solana Local Fee Markets](https://www.helius.dev/blog/solana-local-fee-markets.md): This article provides an accessible analysis of the current state of Solana's local fee markets and what needs to improve. - [Solana MEV Report: Trends, Insights, and Challenges ](https://www.helius.dev/blog/solana-mev-report.md): Explore the current Solana MEV landscape with concrete examples and quantifiable, contextual data to illustrate the scope and impact of MEV. - [Announcing the Helius Startup Launchpad](https://www.helius.dev/blog/helius-startup-launchpad.md): Partnering with Solana's top investors to help early-stage startups with resources and support to execute like world-class companies. - [Beyond the Tech Bro: Rethinking Hero Worship in Crypto](https://www.helius.dev/blog/beyond-the-tech-bro-rethinking-hero-worship-in-crypto.md): Cult of Personality. Great Man Theory of History. The Potency of Ideas. Decentralized Leadership. Grassroot Organizations. Crypto-Optimism. - [All You Need to Know About hSOL ](https://www.helius.dev/blog/what-is-hsol.md): Learn the benefits of the hSOL Liquid Staking Token (LST), purchasing it on a DEX, and how to convert Helius stake accounts into hSOL using Sanctum. - [DoubleZero: A Faster Internet](https://www.helius.dev/blog/doublezero-a-faster-internet.md): DoubleZero is building a fast global fiber optic network to meet the demands of high-throughput, low-latency distributed systems including Solana. - [Introducing: Faster getProgramAccounts (gPA) Calls](https://www.helius.dev/blog/faster-getprogramaccounts.md): Learn how to optimize your getProgramAccount (gPA) calls on Solana to get up to 10x faster results - [Funding Announcement](https://www.helius.dev/blog/funding-announcement.md): With a $21.75M raise led by Haun Ventures & Founders Fund, we're boosting developers' economic potential via crypto. - [Solana Staking Simplified: A Complete Guide to SOL Staking](https://www.helius.dev/blog/solana-staking-simplified-guide-to-sol-staking.md): A concise overview of staking SOL. We answer the most common questions and cover all the key areas you need to know. - [Poseidon: Build Solana Programs with TypeScript](https://www.helius.dev/blog/build-solana-programs-with-typescript-poseidon.md): Poseidon is a new transpiler framework that empowers web developers to create Solana on-chain programs with TypeScript. - [Solana Executive Overview](https://www.helius.dev/blog/solana-executive-overview.md): An overview of Solana's core protocol, covering Gulf Stream, TPU, Turbine, consensus, gossip, and block verification. - [How to Start Building with the Solana Web3.js 2.0 SDK](https://www.helius.dev/blog/how-to-start-building-with-the-solana-web3-js-2-0-sdk.md): Anza Labs launched Web3.js 2.0 SDK with modern JavaScript features. This article covers updates and a transaction example. - [Agave 2.0 Transition: A Developer Guide](https://www.helius.dev/blog/agave-2-0-transition.md): Helius strongly recommends our developer community to review the following changes before the Agave 2.0 Mainnet-Beta client release - [Asynchronous Program Execution: Dawn of a New Solana APE-och](https://www.helius.dev/blog/asynchronous-program-execution.md): A detailed examination of Async Execution, a major protocol update championed by Solana co-founder Anatoly Yakovenko - [ZK Compression Keynote: Breakpoint 2024](https://www.helius.dev/blog/zk-compression-keynote-breakpoint-2024.md): ZK compression—what it is, how it works, and, most importantly, why it’s crucial for the future of Solana. - [Measuring Solana’s Decentralization: Facts and Figures](https://www.helius.dev/blog/solana-decentralization-facts-and-figures.md): An analysis of Solana’s decentralization using verifiable data, comparing its metrics to other blockchains. - [Solana Congestion: How to Best Send Solana Transactions](https://www.helius.dev/blog/solana-congestion-how-to-best-send-solana-transactions.md): This guide covers strategies for successful transactions during congestion, including priority fees and optimization. - [Agave v2.0 Update All You Need to Know](https://www.helius.dev/blog/agave-v2-update.md): Summary of key Solana Agave 2.0 features and optimizations, including syscalls, economic changes, and ZK ElGamal Proof. - [Optimizing Solana Programs](https://www.helius.dev/blog/optimizing-solana-programs.md): A guide on Solana program optimization, covering Anchor to low-level unsafe Rust, balancing performance, safety, and usability. - [Create a Solana Telegram Bot in Less Than 100 Lines of Code](https://www.helius.dev/blog/create-a-solana-telegram-bot-in-less-than-100-lines-of-code.md): This guide demonstrates how to create a customizable Telegram bot that tracks real-time events using Helius webhooks and Cloudflare Workers. - [Is Solana’s inflation too high?](https://www.helius.dev/blog/solana-issuance-inflation-schedule.md): A comprehensive analysis of Solana's inflation schedule and issuance. - [How to Land Transactions on Solana ](https://www.helius.dev/blog/how-to-land-transactions-on-solana.md): Learn why Solana transactions fail and follow these recommended best practices to improve landing rates and increase throughput. - [The Solana Foundation Delegation Program & the Challenges Facing Long-tail Validators](https://www.helius.dev/blog/solana-foundation-delegation-program-sfdp.md): Report analyzing the effects of the Solana Foundation's Delegation Program (SFDP) and the challenges facing Solana's long-tail validators. - [How to Mine Ore: A Beginner-Friendly Guide](https://www.helius.dev/blog/how-to-mine-ore-a-beginner-friendly-guide.md): This article explores Proof of Work, Bitcoin mining origins, and compares it to ORE mining via web app and CLI. - [All You Need to Know About Solana's v1.18 Update](https://www.helius.dev/blog/all-you-need-to-know-about-solanas-v1-18-update.md): Learn about the latest update to the Solana Labs (now Agave) client, as well as the new central scheduler - [Zero-Knowledge Proofs: An Introduction to the Fundamentals](https://www.helius.dev/blog/zero-knowledge-proofs-an-introduction-to-the-fundamentals.md): Learn the theory, mathematics, and cryptography that power the most powerful devised by cryptographers — zero-knowledge proofs. - [A Short Introduction to DePIN](https://www.helius.dev/blog/a-short-introduction-to-depin.md): This short introduction will explain DePIN, its functions, and its applications, such as telecommunication, storage, maps, and computing. - [Solana Builders - Ore: A New International Money](https://www.helius.dev/blog/solana-builders---ore-a-new-international-money.md): Learn about Ore, a Bitcoin-like peer-to-peer electronic currency implemented as a program atop Solana, with kel xyz - [Solana’s Gulf Stream: Mo Mempool, Mo problems](https://www.helius.dev/blog/solana-gulf-stream.md): An exploration of Gulf Stream, Solana's mempool-less transaction forwarding protocol - [Zero-Knowledge Proofs: Its Applications on Solana](https://www.helius.dev/blog/zero-knowledge-proofs-its-applications-on-solana.md): Learn about zero-knowledge proofs, and how Solana is shaping up to be a ZK juggernaut - [Solana Builders: ZK Compression](https://www.helius.dev/blog/solana-builders-zk-compression.md): Learn about ZK Compression — all its properties and caveats — with Overclock's dubbelosix - [How to Monitor Solana Transactions Using Geyser Enhanced Websockets](https://www.helius.dev/blog/how-to-monitor-solana-transactions-using-geyser-enhanced-websockets.md): Learn how to master Geyser Enhanced Websockets with simple and complex examples - [Stake-Weighted Quality of Service: Everything You Need to Know](https://www.helius.dev/blog/stake-weighted-quality-of-service-everything-you-need-to-know.md): Learn about Stake-Weighted Quality of Service (SWQoS), how Solana processes transactions, and the growing importance of validators and stake - [Consensus on Solana](https://www.helius.dev/blog/consensus-on-solana.md): Contextualizing the Role of Proof-of-History within Slots in Tower BFT, Solana’s Consensus Mechanism - [All You Need to Know About Solana's v1.17 Update](https://www.helius.dev/blog/all-you-need-to-know-about-solanas-v1-17-update.md): Learn about Solana's v1.17 update, the latest upgrade to the Solana Labs validator client, as well as the recent February network outage. - [Futarchy and Governance: Prediction Markets Meet DAOs on Solana](https://www.helius.dev/blog/futarchy-and-governance-prediction-markets-meet-daos-on-solana.md): Learn about Futarchy, how it works, and how it's being implemented on Solana via the Meta-DAO. - [How to Stake SOL on Solana](https://www.helius.dev/blog/how-to-stake-solana.md): Learn how to natively stake SOL, how Liquid Staking Tokens (LSTs) like hSOL work, and how staking improves the Solana network. - [Solana Fees in Theory and Practice](https://www.helius.dev/blog/solana-fees-in-theory-and-practice.md): An exploration of Solana fees in theory and practice. - [Solana MEV: An Introduction](https://www.helius.dev/blog/solana-mev-an-introduction.md): An introduction to MEV on Solana. - [What are Token Extensions?](https://www.helius.dev/blog/what-is-token-2022.md): A deep look into Token Extensions and how they will power the next generation of tokens on Solana. - [How to Deal with Blockhash Errors on Solana](https://www.helius.dev/blog/how-to-deal-with-blockhash-errors-on-solana.md): This blog explains blockhash errors, their causes, and best practices for avoiding them. - [How to Monitor a Raydium Liquidity Pool](https://www.helius.dev/blog/how-to-monitor-a-raydium-liquidity-pool.md): Liquidity pools enable crypto trading on DEXs and other DeFi platforms. Learn to monitor them using webhooks and websockets in this article. - [How to Set Up a Solana Validator](https://www.helius.dev/blog/how-to-set-up-a-solana-validator.md): Learn how to set up a Solana validator with this step-by-step guide. - [A Guide to Testing Solana Programs](https://www.helius.dev/blog/a-guide-to-testing-solana-programs.md): Learn how to test Solana programs, from theory to practical examples - [How to Fetch Newly Minted Tokens with Helius](https://www.helius.dev/blog/how-to-fetch-newly-minted-tokens-with-helius.md): This article explores how tokens are created on Solana, what SPL tokens are, and how to monitor new tokens and fetch their metadata using Helius. - [Build a cNFT Minter Mobile App in Under 5 Minutes](https://www.helius.dev/blog/build-a-cnft-minter-mobile-app-in-under-5-minutes.md): This tutorial explains building an Android app to capture images and mint compressed NFTs on Solana. - [A Hitchhiker's Guide to Solana Program Security](https://www.helius.dev/blog/a-hitchhikers-guide-to-solana-program-security.md): Learn about Solana program security and how to mitigate common vulnerabilities - [Solana Frames: Minting a cNFT on Farcaster](https://www.helius.dev/blog/solana-frames-minting-a-cnft-on-farcaster.md): Learn about Farcaster, Frames, and how to create a Frame that mints a cNFT to a user's verified Solana address - [Liquid Staking and LSTs on Solana](https://www.helius.dev/blog/lsts-on-solana.md): An exploration into the mechanics of LSTs on Solana. - [How to Get Token Holders on Solana](https://www.helius.dev/blog/how-to-get-token-holders-on-solana.md): This guide explains how to retrieve all holders of a fungible token like USDC for tracking or airdrop purposes. - [Plug and Play Token Extensions](https://www.helius.dev/blog/plug-and-play-token-extensions.md): Build with Token Extensions on Solana Playground - [How to build a Solana Portfolio Viewer with Next.js and Helius's DAS API](https://www.helius.dev/blog/build-a-solana-portfolio-viewer.md): Learn how to integrate the DAS API into a front-end application to build a portfolio viewer for showcasing both NFTs and SPL tokens. - [An Introduction to Anchor: A Beginner’s Guide to Building Solana Programs](https://www.helius.dev/blog/an-introduction-to-anchor-a-beginners-guide-to-building-solana-programs.md): Learn everything you need to know to get started building on Solana with Anchor - [Publishing Solana Mobile Apps: A How To Guide](https://www.helius.dev/blog/publishing-solana-mobile-apps.md): Learn the process of publishing a Solana Mobile dApp, from material preparation to submitting to the dApp store. - [Token Gating on Solana - A Solana Mobile Tutorial](https://www.helius.dev/blog/token-gating-on-solana-mobile-tutorial.md): Learn token-gating on Solana using the Saga Genesis Token. - [Solana Nodes — A Primer on Solana RPCs, Validators, and RPC providers](https://www.helius.dev/blog/solana-nodes-a-primer-on-solana-rpcs-validators-and-rpc-providers.md): Learn about Solana nodes, the different types, their importance, and the top RPC providers. - [Solana Validator Economics: A Primer](https://www.helius.dev/blog/solana-validator-economics-a-primer.md): Learn how validators earn revenue through fees, tips, and issuance, how they distribute rewards, and the costs to operate a validator. - [How to Migrate From Ethereum to Solana: A Guide for Devs](https://www.helius.dev/blog/how-to-migrate-from-ethereum-to-solana.md): Learn everything you need to know to start programming in Solidity on Solana - [The L1 vs L2 Landscape: Understanding the Design Differences, Tradeoffs, and Endgames](https://www.helius.dev/blog/the-l1-vs-l2-landscape.md): Understanding the L1 and L2 landscape from first principles. - [Priority Fees: Understanding Solana's Transaction Fee Mechanics](https://www.helius.dev/blog/priority-fees-understanding-solanas-transaction-fee-mechanics.md): Learn about Solana's transaction fee mechanics, priority fees, and how to implement them programmatically. - [Gaming: How Solana is Changing the Playfield](https://www.helius.dev/blog/gaming-how-solana-is-changing-the-playfield.md): Learn about Web3 gaming and all the tools you need to get started building Solana-integrated games, today. - [What is Firedancer? A Deep Dive into Solana 2.0](https://www.helius.dev/blog/what-is-firedancer.md): Learn everything you need to know about Firedancer, Solana's new independent validator client developed by Jump. - [The Solana Programming Model: An Introduction to Developing on Solana](https://www.helius.dev/blog/the-solana-programming-model-an-introduction-to-developing-on-solana.md): Learn about the complexities of Solana's architecture, the role of accounts, and how transactions facilitate on-chain interactions. - [Turbine: Block Propagation on Solana](https://www.helius.dev/blog/turbine-block-propagation-on-solana.md): Learn about Solana block propagation, its comparison to Ethereum, and future research on data availability. - [Solana Geyser Plugins: Streaming Data at the Speed of Light](https://www.helius.dev/blog/solana-geyser-plugins-streaming-data-at-the-speed-of-light.md): Learn about Solana Geyser Plugins — how they work, how to make your own, and the streaming services Helius offers - [All You Need to Know About Compression on Solana](https://www.helius.dev/blog/all-you-need-to-know-about-compression-on-solana.md): Learn about state compression, compressed NFTs (cNFTs), as well as how to fetch, mint or transfer them from our most comprehensive article yet - [All You Need to Know About Solana's v1.16 Update](https://www.helius.dev/blog/all-you-need-to-know-about-solanas-v1-16-update.md): Learn about Solana's v1.16 update, the latest upgrade to the Solana Labs validator client - [Solana Dev 101 - Making a Solana Discord Bot with Webhooks](https://www.helius.dev/blog/discord-sales-bot.md): Learn how to create a Discord sales bot for an NFT collection on Solana using Helius's Webhooks - [How to set up a Solana Telegram bot](https://www.helius.dev/blog/solana-telegram-bot.md): Learn how to set up a Telegram bot that sends updates relating to on-chain activities with Helius webhooks. - [Cryptographic Tools 101 - Hash Functions and Merkle Trees Explained](https://www.helius.dev/blog/cryptographic-tools-101-hash-functions-and-merkle-trees-explained.md): Learn the fundamentals of cryptographic primitives, and how primitives such as hash functions and Merkle trees are essential to blockchains. - [Proof of History, Proof of Stake, Proof of Work - Explained](https://www.helius.dev/blog/proof-of-history-proof-of-stake-proof-of-work-explained.md): Learn about consensus algorithms, their importance, how they coordinate network participants, and the importance of time in blockchain technology - [How to Mitigate Spam QUICkly: All You Need to Know About Solana and QUIC](https://www.helius.dev/blog/all-you-need-to-know-about-solana-and-quic.md): Learn about QUIC and how it has improved Solana's network - [Privacy on Solana with Elusiv and Light: All You Need to Know About Privacy on SOL](https://www.helius.dev/blog/privacy-on-solana-with-elusiv-and-light.md): Learn the importance of privacy and how to send SOL privately using Elusiv and the Light Protocol - [Solana DeFi: Jupiter Swap UI (2023)](https://www.helius.dev/blog/solana-defi.md): Start your Solana DeFi journey by building a Jupiter Swap app. Learn the UX flow of adding a Jupiter Swap component into your application. - [Solana NFT: Modifying Compressed NFTs (2023)](https://www.helius.dev/blog/solana-nft.md): Learn to modify Solana NFTs that are set up through the compressed program. - [Solana Transactions: Durable Nonces (2023)](https://www.helius.dev/blog/solana-transactions.md): Learn how to submit Solana transactions with Durable Nonces by sending an offline transaction using JavaScript. - [All You Need to Know About Solana RPCs (2023)](https://www.helius.dev/blog/solana-rpc.md): Demystify the inner workings of Solana RPCs, what makes them function, and how they differ from RPCs on other networks. - [Solana Pay: All You Need To Know](https://www.helius.dev/blog/solana-pay.md): Solana Pay is a standard protocol & set of reference implementations that enable decentralised payments. - [Shopify & Solana Pay: Step-by-Step Guide (2023)](https://www.helius.dev/blog/solana-pay-shopify.md): We demonstrate how to integrate Solana Pay into a Shopify store - looking over both the merchant set up & customer checkout flow. - [Solana Dev 101 - File system wallets + How to create a custom wallet ](https://www.helius.dev/blog/file-system-wallets-how-to-create-a-custom-wallet.md): This blog aims to shed light on what file system wallets are, how to create them, and how to utilize them. - [Solana Dev 101 - Deserializing Account Data on Solana](https://www.helius.dev/blog/solana-dev-101-deserializing-account-data-on-solana.md): Learn how to deserialize raw account data on Solana. - [Solana Dev 101 — How to Transfer Solana Tokens with Typescript](https://www.helius.dev/blog/solana-dev-101-how-to-transfer-solana-tokens-with-typescript.md): Learn how to transfer an NFT or SPL Token on Solana using TypeScript. - [Solana Dev 101 - Creating a SvelteKit App with the New DAS API](https://www.helius.dev/blog/solana-dev-101-creating-a-sveltekit-app-with-the-new-das-api.md): Learn how to display NFTs on SvelteKit using the DAS API's new SDK. - [Uploading Files to Shadow Drive on Solana](https://www.helius.dev/blog/uploading-files-to-shadow-drive-on-solana.md): Learn how to upload files to SHDW on Solana using TypeScript. - [Solana RPCs and Helius](https://www.helius.dev/blog/solana-rpcs-and-helius.md): The story behind Helius RPCs and their evolution in the Solana ecosystem. - [Top 15 Best Solana RPC Providers (2026)](https://www.helius.dev/blog/top-solana-rpcs-helius-vs-other-node-providers.md): Compare the top 15 Solana RPC providers across latency, performance, plan pricing, and cost per request with benchmarks provided - [Solidity on Solana — What is Solang?](https://www.helius.dev/blog/solidity-on-solana-what-is-solang.md): Solidity is now available for the Solana blockchain through Solang. Learn about it more here! - [Build a Wallet Tracker on Solana](https://www.helius.dev/blog/build-a-wallet-tracker-on-solana.md): Everything you need to know to setup a wallet tracker on Solana with Helius Webhooks. - [Solana Dev 101 - How to Create a Solana Transaction](https://www.helius.dev/blog/how-to-create-a-solana-transaction.md): Learn how to create and send a transaction with Javascript on Solana. This is a beginner-friendly guide, so don't worry if you're new to Solana. - [Solana Dev 101 - How to Mint an NFT on Solana](https://www.helius.dev/blog/how-to-mint-an-nft-on-solana.md): Learn how to create and mint your own NFTs on Solana using JavaScript. - [Solana Dev 101 - Email Notifications for dApps](https://www.helius.dev/blog/webhook-to-email.md): Vercel backend and Replit designed to receive onchain Solana data from Helius’ webhooks and send a message to a given email in real time. - [Solana Dev 101 - Mint SPL Tokens on Solana](https://www.helius.dev/blog/working-with-solana-tokens.md): Learn how to mint tokens on the Solana blockchain. - [All You Need to Know About Solana’s New DAS API ](https://www.helius.dev/blog/all-you-need-to-know-about-solanas-new-das-api.md): Learn all about Solana's new DAS API and it's methods. - [Solana Dev 101 - Using DAS API For Fetching all NFTs in a Collection](https://www.helius.dev/blog/solana-dev-101-using-das-to-return-all-collection-assets.md): Use the DAS API to fetch all NFTs in a Solana collection using JavaScript. - [Listening to Onchain Events on Solana](https://www.helius.dev/blog/solana-data-streaming.md): Listening to On-chain Events on Solana with Geyser, Websockets, or Webhooks. - [Solana Dev101- How to get the holders of an NFT collection (Snapshot)](https://www.helius.dev/blog/nft-holder-snapshots.md): Learn how to get all the owners of an NFT collection on Solana. - [Understanding Slots, Blocks, and Epochs on Solana](https://www.helius.dev/blog/solana-slots-blocks-and-epochs.md): A deep dive on how Solana slots, blocks, and epochs work together. - [How Solana RPCs Work](https://www.helius.dev/blog/how-solana-rpcs-work.md): Demystify the inner workings of Solana RPCs, what makes them function, and how they differ from RPCs on Ethereum. - [Join the Helius Hacker Program and Shape the Future of Solana](https://www.helius.dev/blog/join-the-helius-hacker-program-and-shape-the-future-of-solana.md): Join a like-minded community of Solana developers. - [Exploring NFT Compression on Solana](https://www.helius.dev/blog/solana-nft-compression.md): Learn how to work with NFT Compression on Solana.