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

# Sender SWQOS-Only: Cost-Optimized Low-Latency Sending

> Send Solana transactions through Helius Sender's cost-optimized SWQOS-only path with a 0.000005 SOL minimum tip. Low latency at the lowest tip.

## Overview

SWQOS-only is the cost-optimized [Helius Sender](https://www.helius.dev/docs/sending-transactions/sender.md) tier. It routes your transaction through a single fast SWQOS (stake-weighted quality of service) path with the **lowest minimum tip of any Sender tier: 0.000005 SOL**.

Use this tier when you want low-latency sending at the lowest tip. For highly contested transactions where the fastest landing matters, use the [Sender Max](https://www.helius.dev/docs/sending-transactions/sender-max.md) tier instead.

> [card] Lowest Tip
>
> Minimum tip of just 0.000005 SOL — the cheapest way to use Sender

> [card] Single Fast Path
>
> Routes exclusively through SWQOS infrastructure for low-latency delivery

> [card] No Credits
>
> Available on all plans without consuming API credits

> [card] Single Pathway
>
> Routes through one SWQOS path only — for multi-path routing and the fastest
> landing, use the Sender Max tier

## When to use SWQOS-only

> [card] Good fit
>
> Cost-sensitive trading, high transaction volume, and flows where a single
> fast path is sufficient to land reliably.

> [card] [Consider Sender Max instead](https://www.helius.dev/docs/sending-transactions/sender-max.md)
>
> Highly contested accounts, competitive launches, or any transaction where
> you need the fastest possible landing.

## How to enable SWQOS-only

Add the `swqos_only=true` query parameter to any Sender endpoint URL. 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?swqos_only=true
```

**Backend / server (regional HTTP):**

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

This routes your transaction exclusively through SWQOS and applies the lower **0.000005 SOL** minimum tip requirement. See the [Sender endpoints reference](https://www.helius.dev/docs/sending-transactions/sender.md#endpoints) for connection warming and details.

> [!TIP]
>
> Want to avoid validators linked to sandwich attacks? Add
> [`mev-protect=true`](https://www.helius.dev/docs/sending-transactions/mev-protect) alongside `swqos_only`:
> `https://sender.helius-rpc.com/fast?swqos_only=true&mev-protect=true`.

## Requirements

Like every Sender tier, SWQOS-only transactions must include:

* **Tip**: A SOL transfer of at least **0.000005 SOL** to a designated [tip account](https://www.helius.dev/docs/sending-transactions/sender.md#requirements)
* **Priority fee**: A compute unit price instruction via `ComputeBudgetProgram.setComputeUnitPrice`

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

> [!WARNING]
>
> Your transaction must contain both a tip transfer and a compute unit price
> instruction. Without both, it will be rejected.

## Code Example

> [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 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 sendSwqosOnly(
>   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 + minimum SWQOS-only 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.000005 * LAMPORTS_PER_SOL, // SWQOS-only minimum tip
>         })
>       ],
>       payerKey: keypair.publicKey,
>       recentBlockhash: blockhash,
>     }).compileToV0Message()
>   );
>
>   transaction.sign([keypair]);
>
>   // Note the ?swqos_only=true query parameter
>   const SENDER_ENDPOINT = 'https://sender.helius-rpc.com/fast?swqos_only=true';
>   // Backend: use the regional HTTP endpoint closest to your servers
>   // const SENDER_ENDPOINT = 'http://slc-sender.helius-rpc.com/fast?swqos_only=true';
>
>   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
> sendSwqosOnly(Keypair.fromSecretKey(bs58.decode(PRIV_B58)), RECIPIENT);
> ```

> [tab] cURL
>
> ```bash theme={"system"}
> curl "https://sender.helius-rpc.com/fast?swqos_only=true" \
>   -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
>       }
>     ]
>   }'
> ```

> [!NOTE]
>
> The transaction above still uses a 0.000005 SOL tip — the SWQOS-only minimum.
> Tips between 0.000005 SOL and 0.001 SOL are accepted but stay on the single
> SWQOS path. To route across every pathway for the fastest landing, use the
> [Sender Max](https://www.helius.dev/docs/sending-transactions/sender-max.md) tier with a minimum 0.001 SOL
> tip.

## Best Practices

* **Endpoint selection**: Use `https://sender.helius-rpc.com/fast?swqos_only=true` for frontend apps to avoid CORS issues. For backend apps, use the regional HTTP endpoint closest to your servers.
* **Connection warming**: Use the [`/ping` endpoint](https://www.helius.dev/docs/sending-transactions/sender#connection-warming) during idle periods longer than 5 seconds.
* **Priority fees**: Use the [Helius Priority Fee API](https://www.helius.dev/docs/priority-fee-api.md) for real-time recommendations.
* **Retries**: Set `maxRetries: 0` and implement your own retry logic.

## Related

> [card] [Sender Overview](https://www.helius.dev/docs/sending-transactions/sender.md)
>
> Shared concepts: endpoints, connection warming, rate limits, and custom TPS.

> [card] [Sender Max Tier](https://www.helius.dev/docs/sending-transactions/sender-max.md)
>
> The fastest landing via multi-path routing across all pathways (0.001 SOL min
> tip).

> [card] [Transaction Rebates](https://www.helius.dev/docs/sending-transactions/backrun-rebates.md)
>
> Opt in to earn a share of the MEV your transactions create, paid in SOL.

> [card] [MEV Protect](https://www.helius.dev/docs/sending-transactions/mev-protect.md)
>
> Route around validators statistically linked to sandwich attacks.


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