Sender Max: Fastest Solana Transaction Landing - 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.

Sender Max is the highest-performance Helius Sender tier, built for submissions that need to land ahead of the competition. It routes your submission across every available high-speed pathway and enters it into a priority tip buffer that favors the highest tips. Sender Max handles both single transactions and bundles. Both use all pathways (Helius, Jito, Harmonic, Rakurai, etc.) — the only difference is the payload: submit one transaction with sendTransaction, or up to four with sendBundle. This tier requires a minimum tip of 0.001 SOL. For cost-optimized sending on a single path, use the SWQOS-only tier instead.

Fastest Landing

Routed across every high-speed pathway for the highest probability of landing.

Priority Tip Buffer

Your submission enters a priority tip buffer that prioritizes the highest-tipping submissions — tip more to land first.

No Credits

Available on all plans without consuming API credits.

0.001 SOL Minimum Tip

The minimum tip required to enter the priority tip buffer and use every routing pathway.

How it works

When you tip at least 0.001 SOL, your submission — whether a single transaction or a bundle — is routed across every available high-speed pathway and entered into a priority tip buffer. The buffer favors the highest tips, so raising your tip above the minimum increases your chance of landing first.

Tips below 0.001 SOL do not enter the priority tip buffer — they are sent on a best-effort basis through fewer pathways. For predictable low-latency sending at a lower tip, use the SWQOS-only tier (0.000005 SOL).

When to use Max

Good fit

Highly contested accounts, competitive token launches, liquidations, and any transaction where landing first is worth a higher tip.

Consider SWQOS-only instead \ Cost-sensitive or high-volume flows where a single fast path lands reliably.

Requirements

Every Sender Max submission must include:

Skipping preflight (skipPreflight: true) is optional but recommended — Preflight checks increase latency.

Transactions missing the tip or priority fee will be rejected. For bundle-specific rules, see Bundles.

Priority fees

Every transaction must include a priority fee of at least 5,000 lamports, and we recommend at least 10,000 lamports for more reliable landing. The tip enters your transaction into the priority tip buffer, while the priority fee raises its priority in the validator’s scheduler — together they maximize your chance of landing. Set a priority fee with a compute unit price instruction.

import { ComputeBudgetProgram } from "@solana/web3.js";

ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 });

Use the Helius Priority Fee API for real-time fee recommendations based on current network conditions.

Endpoints

Use the global HTTPS endpoint for frontends, or the regional HTTP endpoint closest to your servers for backends.

Frontend / browser (global HTTPS):

https://sender.helius-rpc.com/fast

Backend / server (regional HTTP):

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

See the Sender endpoints reference for connection warming and details.

Want to avoid validators linked to sandwich attacks? Add mev-protect=true to the endpoint URL — it works for both sendTransaction and sendBundle: https://sender.helius-rpc.com/fast?mev-protect=true.

Code Example

@solana/web3.js

cURL

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

const PRIV_B58 = 'Your Private Key';
const RECIPIENT = 'Recipient Address';
const HELIUS_API_KEY = 'Your API Key';
const TIP_ACCOUNTS = [
  "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
  "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
  "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta",
  "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn",
  "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD",
  "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ",
  "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF",
  "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT",
  "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey",
  "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"
];

async function sendWithSenderMax(
  keypair: Keypair,
  recipientAddress: string
): Promise<string> {
  const connection = new Connection(
    `https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY}`
  );

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

// Build transaction: priority fee + recipient transfer + 0.001 SOL tip
  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: 0.001 * 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, // Minimum tip to enter the priority tip buffer
        })
      ],
      payerKey: keypair.publicKey,
      recentBlockhash: blockhash,
    }).compileToV0Message()
  );

transaction.sign([keypair]);

// Frontend: use the global HTTPS endpoint to avoid CORS issues
  const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast';
  // Backend: use the regional HTTP endpoint closest to your servers
  // const SENDER_ENDPOINT = 'http://slc-sender.helius-rpc.com/fast';

const response = await fetch(SENDER_ENDPOINT, {
    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
sendWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)), RECIPIENT);

See all 96 lines

curl "https://sender.helius-rpc.com/fast" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendTransaction",
    "params": [
      "BASE64_ENCODED_TRANSACTION",
      {
        "encoding": "base64",
        "skipPreflight": true,
        "maxRetries": 0
      }
    ]
  }'

For competitive transactions, the 0.001 SOL minimum is unlikely to be competitive. Price your tip closer to the value of the transaction you’re trying to land — the more a successful landing is worth to you, the higher you should tip. The minimum is a floor, not a target.

Bundles

A bundle is just another payload Sender Max accepts. Submit up to 4 fully-signed transactions and they execute atomically (all-or-nothing) in order, entered into the same priority tip buffer as a single transaction — the buffer prioritizes the highest-tipping bundles for the fastest landing.

Provide only the 0.001 SOL Sender tip. Sender Max routes your bundle across every high-speed pathway and adds any pathway tips on your behalf — you don’t add a separate Jito tip, use Jito tip accounts, or set the jito-region header. Those apply only to basic\ bundles.

Requirements

Submit

Send to the Sender endpoint with method: "sendBundle". Use the global HTTPS endpoint for frontends, or any regional endpoint for backends — all Sender regions are supported.

@solana/web3.js

cURL

const PRIV_B58 = 'Your Private Key'; const HELIUS_API_KEY = 'Your API Key'; const TIP_ACCOUNTS = [ "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE", "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ", "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta", "5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn", "2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD", "2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ", "wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF", "3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT", "4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey", "4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or" ];

async function sendBundleWithSenderMax(keypair: Keypair): Promise<string[]> { const connection = new Connection( https://mainnet.helius-rpc.com/?api-key=${HELIUS_API_KEY} );

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

const tipAccount = new PublicKey(TIP_ACCOUNTS[Math.floor(Math.random() * TIP_ACCOUNTS.length)]);

// Transaction 1: your instructions + priority fee + the 0.001 SOL Sender tip const tx1 = new VersionedTransaction( new TransactionMessage({ instructions: [ ComputeBudgetProgram.setComputeUnitLimit({ units: 100_000 }), ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }), // ... your instructions here ... SystemProgram.transfer({ fromPubkey: keypair.publicKey, toPubkey: tipAccount, lamports: 0.001 * LAMPORTS_PER_SOL, // Sender tip — only one tx in the bundle needs it }) ], payerKey: keypair.publicKey, recentBlockhash: blockhash, }).compileToV0Message() ); tx1.sign([keypair]);

// Transaction 2: more instructions — executes after tx1, atomically const tx2 = new VersionedTransaction( new TransactionMessage({ instructions: [ ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 200_000 }), // ... your instructions here ... ], payerKey: keypair.publicKey, recentBlockhash: blockhash, }).compileToV0Message() ); tx2.sign([keypair]);

// Serialize each fully-signed transaction (up to 4) to base64 const bundle = [tx1, tx2].map((tx) => Buffer.from(tx.serialize()).toString('base64'));

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: 'sendBundle', params: [bundle, { encoding: 'base64' }] }) });

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

// Track landing by each transaction's signature (see below) const signatures = [tx1, tx2].map((tx) => bs58.encode(tx.signatures[0])); console.log('Bundle submitted:', signatures); return signatures; }

// Usage sendBundleWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)));


See all 95 lines

```bash
curl "https://sender.helius-rpc.com/fast" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "sendBundle",
    "params": [
      [
        "BASE64_SIGNED_TX_1",
        "BASE64_SIGNED_TX_2"
      ],
      { "encoding": "base64" }
    ]
  }'

Track landing

Track a bundle the same way you track a single transaction — by watching for each transaction’s signature to land. Because the bundle is atomic, confirming any one transaction means the whole bundle landed. You do not use getBundleStatuses or a bundle ID. Use whichever method fits your stack:

Best Practices