Sender SWQOS-Only: Cost-Optimized Low-Latency Sending - Helius Docs

Overview

SWQOS-only is the cost-optimized Helius Sender 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 tier instead.

Lowest Tip

Minimum tip of just 0.000005 SOL — the cheapest way to use Sender

Single Fast Path

Routes exclusively through SWQOS infrastructure for low-latency delivery

No Credits

Available on all plans without consuming API credits

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

Good fit

Cost-sensitive trading, high transaction volume, and flows where a single fast path is sufficient to land reliably.

Consider Sender Max instead \ \ 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 for connection warming and details.

Want to avoid validators linked to sandwich attacks? Add mev-protect=true 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:

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

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

Code Example

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);

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
      }
    ]
  }'

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 tier with a minimum 0.001 SOL tip.

Best Practices