Helius Solana Infrastructure Expert

Helius provides high-performance Solana RPC, real-time data streaming, and developer APIs.

When to Use

• Setting up Solana RPC infrastructure
• Querying NFT/token metadata (DAS API)
• Real-time blockchain data (LaserStream, WebSockets, webhooks)
• Transaction optimization and priority fees
• ZK Compression for cost reduction

Quick Start

1. Get API key: https://dashboard.helius.dev
2. Use RPC URL: https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY

curl https://mainnet.helius-rpc.com/?api-key=YOUR_KEY \
  -X POST -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getBalance","params":["YOUR_WALLET"]}'

Core Services

RPC Endpoints

// Mainnet
const RPC_URL = `https://mainnet.helius-rpc.com/?api-key=${API_KEY}`;

// Devnet
const DEVNET_URL = `https://devnet.helius-rpc.com/?api-key=${API_KEY}`;

Digital Asset Standard (DAS) API

Query NFT and token metadata - handles both regular and compressed NFTs.

Get Single Asset:

const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getAsset',
    params: { id: 'ASSET_MINT_ADDRESS' }
  })
});

Get Assets by Owner:

const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getAssetsByOwner',
    params: {
      ownerAddress: 'WALLET_ADDRESS',
      page: 1,
      limit: 100
    }
  })
});

DAS Methods:

Enhanced Transactions API

Pre-parsed transaction data in human-readable format.

const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransactionsForAddress',
    params: [
      'WALLET_ADDRESS',
      {
        transactionDetails: 'full',
        sortOrder: 'desc',
        limit: 10
      }
    ]
  })
});

Priority Fee API

Get optimal priority fees for fast transaction landing.

const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getPriorityFeeEstimate',
    params: [{
      accountKeys: ['PROGRAM_ID', 'ACCOUNT_1', 'ACCOUNT_2']
    }]
  })
});

const { priorityFeeEstimate } = await response.json();
// Returns: { low, medium, high, veryHigh } in microlamports

LaserStream (Real-Time gRPC)

Ultra-low latency blockchain streaming. Drop-in replacement for Yellowstone gRPC.

import { LaserStream } from '@helius-labs/laserstream';

const stream = new LaserStream({
  apiKey: 'YOUR_API_KEY',
  region: 'fra'  // fra, ams, tyo, sg, ewr, pitt, slc, lax, lon
});

// Subscribe to account changes
stream.subscribeAccount('ACCOUNT_ADDRESS', (update) => {
  console.log('Account updated:', update);
});

// Subscribe to program transactions
stream.subscribeProgram('PROGRAM_ID', (tx) => {
  console.log('Program transaction:', tx);
});

Regions: FRA, AMS, TYO, SG, EWR, PITT, SLC, LAX, LON

Webhooks

Event-driven notifications for blockchain activity.

// Create webhook via API
const webhook = await fetch('https://api.helius.xyz/v0/webhooks', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Authorization': `Bearer ${API_KEY}`
  },
  body: JSON.stringify({
    webhookURL: 'https://your-server.com/webhook',
    transactionTypes: ['NFT_SALE', 'TOKEN_TRANSFER'],
    accountAddresses: ['ADDRESS_TO_WATCH']
  })
});

Webhook Types:

• Account changes
• Transaction confirmations
• Program events
• NFT activity

ZK Compression

Reduce on-chain storage costs by up to 98%.

// Get compressed account
const response = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getCompressedAccount',
    params: { address: 'COMPRESSED_ACCOUNT' }
  })
});

// Get compressed token balances
const balances = await fetch(RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getCompressedTokenBalancesByOwner',
    params: { owner: 'WALLET_ADDRESS' }
  })
});

Pricing & Rate Limits

Feature Availability:

Error Handling

try {
  const response = await fetch(RPC_URL, { method: 'POST', ... });

  // Check rate limits
  const remaining = response.headers.get('X-RateLimit-Remaining');
  const reset = response.headers.get('X-RateLimit-Reset');

  if (response.status === 429) {
    // Rate limited - wait and retry
    await new Promise(r => setTimeout(r, 1000));
    return retry();
  }

  const data = await response.json();
  if (data.error) {
    console.error(`RPC Error ${data.error.code}: ${data.error.message}`);
  }

  return data.result;
} catch (err) {
  // Network error - retry with backoff
}

Best Practices

DO:

• Use confirmed commitment for faster responses
• Use DAS API for NFT queries (not raw getAccountInfo)
• Simulate transactions before sending
• Use getPriorityFeeEstimate for dynamic fees
• Check rate limit headers

DON'T:

• Poll for real-time data (use WebSockets/LaserStream)
• Hardcode priority fees
• Ignore rate limits
• Skip transaction simulation

Common Patterns

Wallet Portfolio

async function getWalletPortfolio(wallet) {
  // Get all assets (NFTs + tokens)
  const assets = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getAssetsByOwner',
      params: { ownerAddress: wallet, page: 1, limit: 1000 }
    })
  }).then(r => r.json());

  // Get SOL balance
  const balance = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getBalance',
      params: [wallet]
    })
  }).then(r => r.json());

  return {
    solBalance: balance.result.value / 1e9,
    assets: assets.result.items
  };
}

Transaction with Priority Fee

async function sendWithPriorityFee(transaction, accounts) {
  // Get priority fee estimate
  const feeEstimate = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'getPriorityFeeEstimate',
      params: [{ accountKeys: accounts }]
    })
  }).then(r => r.json());

  // Add compute budget instruction with priority fee
  const priorityFee = feeEstimate.result.priorityFeeEstimate.high;

  // Simulate first
  const simulation = await fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'simulateTransaction',
      params: [transaction, { commitment: 'confirmed' }]
    })
  }).then(r => r.json());

  if (simulation.result.err) {
    throw new Error(`Simulation failed: ${JSON.stringify(simulation.result.err)}`);
  }

  // Send transaction
  return fetch(RPC_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'sendTransaction',
      params: [transaction, { skipPreflight: true }]
    })
  }).then(r => r.json());
}

Resources

• Helius Docs: https://www.helius.dev/docs
• Dashboard: https://dashboard.helius.dev
• Discord: https://discord.gg/helius

Pull Local Docs

pipx install docpull
docpull https://www.helius.dev/docs -o .claude/skills/helius/docs