> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Helius Sender: Ultra-Low Latency Solana Transaction Submission

> Ultra-low latency Solana transaction submission with multi-path routing. No credits consumed, global endpoints, optimized for high-frequency trading.

## Overview

> [!NOTE]
>
> **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](https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md) 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.

> [card] No Credits
>
> Available on all plans without consuming API credits. You pay per send with
> a SOL tip.

> [card] Multi-Path Routing
>
> Submits across all pathways (Helius, Jito, Harmonic, Rakurai, etc.) for the fastest possible inclusion

> [card] Global Endpoints
>
> HTTPS endpoint auto-routes to the nearest location for frontends, regional
> HTTP for backends

> [card] [50 TPS with an API key](https://www.helius.dev/contact)
>
> Use your existing Helius project API key. Keyless requests are limited to 1 request per second.

## 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](https://www.helius.dev/docs/sending-transactions/sender-max.md) | All high-speed pathways | 0.001 SOL | Yes | Highly contested transactions and bundles needing the fastest landing |
| [SWQOS-only](https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md) | Single SWQOS path | 0.000005 SOL | No | Cost-optimized trading on one fast path |

> [!NOTE]
>
> 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.

> [card] [Sender Max (fastest landing)](https://www.helius.dev/docs/sending-transactions/sender-max.md)
>
> Routed across every pathway and entered into a priority tip buffer for the
> most competitive submissions. Handles both transactions and bundles.

> [card] [SWQOS-only (cost-optimized)](https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md)
>
> 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](https://www.helius.dev/docs/sending-transactions/sender-max.md) tier (0.001 SOL tip). For the lowest-tip option, see [SWQOS-only](https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md).

### 1. Create Your Free Helius Account

Start by creating your free account at the [Helius Dashboard](https://dashboard.helius.dev/dashboard). Sender is available on all plans, including the free tier, and doesn't consume any API credits.

### 2. Get Your API Key

Go to the [API Keys](https://dashboard.helius.dev/api-keys) section and copy your key. Use it for RPC requests and append it to your Sender endpoint for the standard 50 requests per second, per-region limit.

### 3. 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).

> [tab] @solana/web3.js
>
> ```typescript [expandable] theme={"system"}
> 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?api-key=YOUR_API_KEY', {
>     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');
> ```

> [tab] @solana/kit
>
> ```typescript [expandable] theme={"system"}
> 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';
>
> const TIP_ACCOUNTS = [
>   "4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE",
>   "D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ",
>   "9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta"
>   // ... more tip accounts available
> ];
>
> async function sendWithSender(
>   privateKeyB58: string,
>   recipientAddress: string
> ): Promise<string> {
>   // Load signer from base58 private key
>   const ownerSigner = await createKeyPairSignerFromBytes(bs58.decode(privateKeyB58));
>
>   // Init RPC and fetch blockhash
>   const rpc = createSolanaRpc('https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY');
>   const { value: blockhash } = await rpc.getLatestBlockhash().send();
>
>   // Build + sign transaction
>   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...');
>
>   // Send via Sender
>   const res = await fetch("https://sender.helius-rpc.com/fast?api-key=YOUR_API_KEY", {
>     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');
> ```

### 4. Success! Understanding What Happened

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

* No credits consumed: Sender is credit-free for all users
* Multi-path routing: Your transaction was submitted across all pathways (Helius, Jito, Harmonic, Rakurai, etc.) simultaneously
* Required tip: A 0.001 SOL tip enters the priority tip buffer and uses every routing pathway. See [tiers](#choose-your-tier) for the lower-tip SWQOS-only option
* Priority fee: Signals validators your willingness to pay for priority processing
* Skipped preflight (optional): Trades validation for speed — Sender also supports preflight checks

## Requirements

> [!WARNING]
>
> **Mandatory requirements**: Every Sender transaction must include a tip
> (minimum 0.001 SOL for [Sender Max](https://www.helius.dev/docs/sending-transactions/sender-max.md), or
> 0.000005 SOL for [SWQOS-only](https://www.helius.dev/docs/sending-transactions/sender-swqos-only.md)) and a
> priority fee.

> [!NOTE]
>
> `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**:

* **Tip**: A SOL transfer to a designated tip account. Minimum 0.001 SOL for Sender Max, or 0.000005 SOL for SWQOS-only.
* **Priority fee**: Compute unit pricing via `ComputeBudgetProgram.setComputeUnitPrice` to prioritize your transaction in the validator queue.

> [accordion] Designated Tip Accounts (mainnet-beta)
>
> ```text theme={"system"}
> 4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE
> D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ
> 9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta
> 5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn
> 2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD
> 2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ
> wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF
> 3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT
> 4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey
> 4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or
> ```

#### Why both are required

* **Tips**: Give you access to all of Sender's routing pathways (Helius, Jito, Harmonic, Rakurai, etc.) and the priority tip buffer
* **Priority fees**: Signal to validators your willingness to pay for priority processing through Solana's native prioritization system
* **Together**: Tips maximize the pathways your transaction can take, while priority fees improve its priority with validators — together they maximize inclusion probability

Use the [Helius Priority Fee API](https://www.helius.dev/docs/priority-fee-api.md) for real-time priority fee recommendations.

## Endpoints

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

> [tab] Frontend/Browser Applications
>
> **Recommended for frontend applications to avoid CORS issues:**
>
> ```
> https://sender.helius-rpc.com/fast   # Global HTTPS endpoint
> ```
>
> > [!NOTE]
> >
> > 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.

> [tab] Backend/Server Applications
>
> **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
> ```
>
> > [!NOTE]
> >
> > For backend/server applications, choose the regional HTTP endpoint closest
> > to your infrastructure for optimal performance.

> [tab] Connection Warming
>
> **HTTPS (Frontend):**
>
> ```
> https://sender.helius-rpc.com/ping   # Global HTTPS ping (auto-routes to nearest location)
> ```
>
> **HTTP (Backend):**
>
> ```
> http://slc-sender.helius-rpc.com/ping   # Salt Lake City
> http://ewr-sender.helius-rpc.com/ping   # Newark
> http://lon-sender.helius-rpc.com/ping   # London
> http://fra-sender.helius-rpc.com/ping   # Frankfurt
> http://ams-sender.helius-rpc.com/ping   # Amsterdam
> http://sg-sender.helius-rpc.com/ping    # Singapore
> http://tyo-sender.helius-rpc.com/ping   # Tokyo
> ```

## 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:

```bash theme={"system"}
# 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
```

```typescript theme={"system"}
// 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);
```

> [!NOTE]
>
> 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.

```typescript theme={"system"}
{
  "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
    }
  ]
}
```

See the [Quickstart](#quickstart-guide) for a complete, runnable `sendTransaction` example.

### sendBundle

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

```typescript theme={"system"}
{
  "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" }
  ]
}
```

See [Sender Max bundles](https://www.helius.dev/docs/sending-transactions/sender-max.md#bundles) for a full example and how to track landing.

### 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
```

See [MEV Protect](https://www.helius.dev/docs/sending-transactions/mev-protect.md) for how it works and its tradeoffs.

> [card] [API Reference](https://www.helius.dev/docs/api-reference/sender/sendtransaction.md)
>
> View the complete Sender API reference with request/response schemas and
> parameters.

## Rate Limits and Scaling

* **Keyless**: 1 request per second per egress IP, per region. Callers behind the same NAT share this limit. Rejected `429` requests count toward the limit; `/ping` does not.
* **With an API key**: 50 requests per second per key, per region. Append your existing Helius project API key to the Sender endpoint as `?api-key=YOUR_API_KEY`.
* **No Credit Usage**: Sender transactions don't consume API credits from your plan
* **Higher Limits**: Approved limits above 50 requests per second use a dedicated Sender key.

### API Key Authentication

> [!NOTE]
>
> Use your existing Helius project API key for the standard 50 requests per
> second limit. You only need a dedicated Sender key for an approved limit
> above 50 requests per second.

Append the API key as a query parameter to your endpoint URL:

> [tab] Frontend/Browser Applications
>
> ```
> https://sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> ```

> [tab] Backend/Server Applications
>
> ```
> http://slc-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> http://ewr-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> http://lon-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> http://fra-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> http://ams-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> http://sg-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> http://tyo-sender.helius-rpc.com/fast?api-key=YOUR_API_KEY
> ```

> [!TIP]
>
> Need more than 50 TPS or a custom plan? [Request higher
> limits](https://www.helius.dev/contact) and explore custom tip arrangements
> for Sender by contacting our sales team.

## Support

Get support through the [Helius Dashboard](https://dashboard.helius.dev) or join [Discord](https://discord.com/invite/6GXdee3gBj) for assistance.

## See Also: Shred Delivery

[Raw Shreds (UDP)](https://www.helius.dev/docs/shred-delivery/raw-shreds.md) 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, and RPC node operators who want to remove network sync latency.

> [!TIP]
>
> Start receiving raw shreds. [Subscribe to Helius Shred
> Delivery](https://dashboard.helius.dev/shred-delivery-seats) in your dashboard.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.