Send Solana transactions and bundles through Helius Sender’s fastest-landing tier. Access all pathways (Helius, Jito, Harmonic, Rakurai, etc.) for every submission, with a 0.001 SOL minimum tip.
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
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).
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. Your total priority fee is the compute unit price (in micro-lamports) multiplied by your compute unit limit:
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.
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.
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.
Up to 4 transactions, fully signed. They execute sequentially and atomically — if any fails, the whole bundle is rejected.
Tip: at least one transaction must transfer at least 0.001 SOL to a designated Sender tip account. This is the same Sender tip used for single transactions — Helius adds any pathway tips (including Jito) for you, so you don’t add a separate Jito tip.
Priority fee: each transaction must include a priority fee of at least 5,000 lamports.
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
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 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;}// UsagesendBundleWithSenderMax(Keypair.fromSecretKey(bs58.decode(PRIV_B58)));
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:
Endpoint selection: Use https://sender.helius-rpc.com/fast for frontend apps to avoid CORS issues. For backend apps, use the regional HTTP endpoint closest to your servers.
Dynamic tipping: Raise your tip above 0.001 SOL for highly contested transactions to improve your priority in the tip buffer.
Connection warming: Use the /ping endpoint during idle periods longer than 5 seconds.
