Helius Sender: Ultra-Low Latency Solana Transaction Submission - Helius Docs

Overview

Pricing update: Sender Max now uses a 0.001 SOL minimum tip. This enters you into a priority tip buffer for top of block — tip more to land first. The cost-optimized SWQOS-only tier remains at 0.000005 SOL.

Helius Sender is a specialized service for ultra-low latency transaction submission, built for latency-sensitive trading. It submits your transaction across all pathways (Helius, Jito, Harmonic, Rakurai, etc.) simultaneously to give it the fastest possible route into a block.Sender does not consume API credits — you pay per transaction with a SOL tip. It is available on every plan, including the free tier.

No Credits

Available on all plans without consuming API credits. You pay per send with a SOL tip.

Multi-Path Routing

Submits across all pathways (Helius, Jito, Harmonic, Rakurai, etc.) for the fastest possible inclusion

Global Endpoints

HTTPS endpoint auto-routes to the nearest location for frontends, regional HTTP for backends

50 TPS (Default) \ Need more? Request higher limits and custom tip arrangements

Choose your tier

Sender offers two tiers. Both are low-latency and credit-free — the difference is how many pathways your transaction takes and the minimum tip required.

Tier Routing Minimum tip Tip buffer Best for
Sender Max All high-speed pathways 0.001 SOL Yes Highly contested transactions and bundles needing the fastest landing
SWQOS-only Single SWQOS path 0.000005 SOL No Cost-optimized trading on one fast path

Tips between 0.000005 SOL and 0.001 SOL are accepted but do not enter the priority tip buffer — they are sent on a best-effort basis through fewer pathways. To get buffer priority and every routing pathway, tip at least 0.001 SOL.

Sender Max (fastest landing) \ Routed across every pathway and entered into a priority tip buffer for the most competitive submissions. Handles both transactions and bundles.

SWQOS-only (cost-optimized) \ Lowest tip, single fast path. Add ?swqos_only=true to any endpoint URL.

Quickstart Guide

Ready to submit your first ultra-low latency Solana transaction? This guide gets you started in minutes. The best part: you don’t need any paid plan or special access — Sender is available to all users and doesn’t consume API credits.The example below uses the Sender Max tier (0.001 SOL tip). For the lowest-tip option, see SWQOS-only.

  1. Create Your Free Helius Account

Start by creating your free account at the Helius Dashboard. Sender is available on all plans, including the free tier, and doesn’t consume any API credits.

  1. Get Your API Key

Go to the API Keys section and copy your key. Use this for getting blockhashes and transaction confirmation. Sender will handle transaction submission.

  1. Send Your First Transaction

Let’s send a simple SOL transfer using Sender. This example includes the required tip and priority fee, and skips preflight for lower latency (optional).

import { Connection, TransactionMessage, VersionedTransaction, SystemProgram, PublicKey, Keypair, LAMPORTS_PER_SOL, ComputeBudgetProgram } from '@solana/web3.js';
import bs58 from 'bs58';

const TIP_ACCOUNTS = [ 
  "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE", 
  "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ", 
  "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta" 
  // ... more tip accounts available 
];

async function sendWithSender( keypair: Keypair, recipientAddress: string ): Promise<string> {
  const connection = new Connection( 'https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY' );

const { value: { blockhash } } = await connection.getLatestBlockhashAndContext('confirmed');

// Build transaction with tip transfer and transfer to recipient
  const transaction = new VersionedTransaction(
    new TransactionMessage({
      instructions: [
        ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }),
        ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }),
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(recipientAddress),
          lamports: 1 * LAMPORTS_PER_SOL,
        }),
        SystemProgram.transfer({
          fromPubkey: keypair.publicKey,
          toPubkey: new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
          lamports: 0.001 * LAMPORTS_PER_SOL,
        })
      ],
      payerKey: keypair.publicKey,
      recentBlockhash: blockhash,
    }).compileToV0Message()
  );

transaction.sign([keypair]);
  console.log('Sending transaction via Sender endpoint...');

const response = await fetch('https://sender.helius-rpc.com/fast', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: Date.now().toString(),
      method: 'sendTransaction',
      params: [
        Buffer.from(transaction.serialize()).toString('base64'),
        {
          encoding: 'base64',
          skipPreflight: true, // Optional: skip for lower latency
          maxRetries: 0
        }
      ]
    })
  });

const json = await response.json();
  if (json.error) {
    throw new Error(json.error.message);
  }

console.log('Transaction sent:', json.result);
  return json.result;
}

// Usage
const keypair = Keypair.fromSecretKey(bs58.decode('YOUR_PRIVATE_KEY'));
sendWithSender(keypair, 'RECIPIENT_ADDRESS');

See all 84 lines

import { pipe } from "@solana/kit";
import { createSolanaRpc, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction, signTransactionMessageWithSigners, lamports, getBase64EncodedWireTransaction, createKeyPairSignerFromBytes, address, } from "@solana/kit";
import { getTransferSolInstruction } from "@solana-program/system";
import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction, } from "@solana-program/compute-budget";
import bs58 from 'bs58';

async function sendWithSender( privateKeyB58: string, recipientAddress: string ): Promise<string> {
  const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(privateKeyB58));

const rpc = createSolanaRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');
  const { value: blockhash } = await rpc.getLatestBlockhash().send();

const tx = pipe(
    createTransactionMessage({ version: 0 }),
    (m) => setTransactionMessageFeePayerSigner(ownerSigner, m),
    (m) => setTransactionMessageLifetimeUsingBlockhash(blockhash, m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 100_000 }), m),
    (m) => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 200_000 }), m),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: address(recipientAddress),
          amount: lamports(1_000_000_000n), // 1 SOL
        }),
        m
      ),
    (m) =>
      appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: ownerSigner,
          destination: address(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]),
          amount: lamports(1_000_000n), // 0.001 SOL
        }),
        m
      )
  );

const signedTx = await signTransactionMessageWithSigners(tx);
  const base64Tx = getBase64EncodedWireTransaction(signedTx);

console.log('Sending transaction via Sender endpoint...');

const res = await fetch("https://sender.helius-rpc.com/fast", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: Date.now().toString(),
      method: "sendTransaction",
      params: [
        base64Tx,
        { encoding: "base64", skipPreflight: true, maxRetries: 0 },
      ],
    }),
  });

const { result: sig, error } = await res.json();
  if (error) throw new Error(error.message);

console.log("Transaction sent: ", sig);
  return sig;
}

// Usage
sendWithSender('YOUR_PRIVATE_KEY', 'RECIPIENT_ADDRESS');

See all 94 lines

Success! Understanding What Happened

You’ve successfully submitted a transaction via Sender! Here’s what made it work:

Requirements

Mandatory requirements: Every Sender transaction must include a tip (minimum 0.001 SOL for Sender Max, or 0.000005 SOL for SWQOS-only) and a priority fee.

skipPreflight is optional — Sender supports preflight checks. Set skipPreflight: true to trade validation for lower latency.

Tips and priority fees

All transactions submitted through Sender must include both a tip and a priority fee:

Designated Tip Accounts (mainnet-beta)

4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE
D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ
9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta
5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn
2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD
2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ
wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF
3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT
4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey
4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or

Why both are required

Use the Helius Priority Fee API for real-time priority fee recommendations.

Endpoints

Sender endpoints are available in multiple configurations depending on your use case:

Recommended for frontend applications to avoid CORS issues:

https://sender.helius-rpc.com/fast   # Global HTTPS endpoint

The HTTPS endpoint resolves CORS preflight failures that occur with browser-based applications when using the regional HTTP endpoints. This endpoint automatically routes to the nearest location for optimal performance. Use this for frontend/browser use cases.

Regional HTTP endpoints for optimal server-to-server latency:

http://slc-sender.helius-rpc.com/fast   # Salt Lake City
http://ewr-sender.helius-rpc.com/fast   # Newark
http://lon-sender.helius-rpc.com/fast   # London
http://fra-sender.helius-rpc.com/fast   # Frankfurt
http://ams-sender.helius-rpc.com/fast   # Amsterdam
http://sg-sender.helius-rpc.com/fast    # Singapore
http://tyo-sender.helius-rpc.com/fast   # Tokyo

For backend/server applications, choose the regional HTTP endpoint closest to your infrastructure for optimal performance.

Connection Warming

For applications with long periods between transaction submissions, use the ping endpoint to maintain warm connections and reduce cold start latency. The ping endpoint accepts simple GET requests and returns a basic response to keep connections alive:

# Frontend applications - use HTTPS (auto-routes to nearest location)
curl https://sender.helius-rpc.com/ping

# Backend applications - use regional HTTP
curl http://slc-sender.helius-rpc.com/ping

// Keep connection warm during idle periods
async function warmConnection(endpoint: string) {
  try {
    const response = await fetch(`${endpoint}/ping`);
    console.log("Connection warmed:", response.ok);
  } catch (error) {
    console.warn("Failed to warm connection:", error);
  }
}

// Frontend applications - use HTTPS endpoint
setInterval(() => {
  warmConnection("https://sender.helius-rpc.com");
}, 5000);

// Backend/server applications - use regional HTTP endpoint
setInterval(() => {
  warmConnection("http://slc-sender.helius-rpc.com");
}, 5000);

Use connection warming when your application has gaps longer than 5 seconds between transactions to maintain optimal submission latency.

Request Format

Sender accepts two methods on the same endpoint. Every submission must include both a tip and a priority fee; skipping preflight is optional (it lowers latency).

sendTransaction

Submit a single transaction. It must contain both a SOL transfer with the minimum tip to a designated tip account and a compute unit price instruction — without both, it will be rejected.

{
  "id": "unique-request-id",
  "jsonrpc": "2.0",
  "method": "sendTransaction",
  "params": [
    "BASE64_ENCODED_TRANSACTION", // Must include both tip and priority fee instructions
    {
      "encoding": "base64",
      "skipPreflight": true,       // Optional: skip for lower latency
      "maxRetries": 0
    }
  ]
}

sendBundle

Submit up to 4 fully-signed transactions for atomic, all-or-nothing execution. At least one transaction must carry the tip.

{
  "id": "unique-request-id",
  "jsonrpc": "2.0",
  "method": "sendBundle",
  "params": [
    ["BASE64_SIGNED_TX_1", "BASE64_SIGNED_TX_2"], // Up to 4; at least one carries the tip
    { "encoding": "base64" }
  ]
}

MEV Protect (optional)

To route around validators statistically linked to sandwich attacks, add the mev-protect=true query parameter to the endpoint URL. It works on both Sender tiers and on both sendTransaction and sendBundle, with no changes to your request body.

https://sender.helius-rpc.com/fast?mev-protect=true                    # Sender Max
https://sender.helius-rpc.com/fast?swqos_only=true&mev-protect=true     # SWQOS-only

Rate Limits and Scaling

Custom TPS with API Key Authentication

This section is only relevant if you have been granted increased TPS limits and received an API key from the Helius team. Standard users can skip this section.

If you have been approved for higher TPS limits, you will receive a dedicated API key for Sender. To use it, append the API key as a query parameter to your endpoint URL:

https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY

Support

Get support through the Helius Dashboard or join Discord for assistance.

See Also: Shred Delivery

Raw Shreds (UDP) is our specialized delivery of raw Solana shreds via UDP, built to give you ultra low-latency access to Solana’s raw transaction data. By delivering unprocessed shreds directly from the network, Shred Delivery provides a competitive edge for propAMMs, snipers, copy traders, liquidation bots, arbitrage, and RPC node operators who want to remove network sync latency.

Start receiving raw shreds. Subscribe to Helius Shred Delivery in your dashboard.