## Overview

SWQOS-only is the cost-optimized [Helius Sender](/content/docs/sending-transactions/sender/index.html) 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](/content/docs/sending-transactions/sender-max/index.html) 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**](/content/docs/sending-transactions/sender-max/index.html) \ 
\ 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](/content/docs/sending-transactions/sender#endpoints/index.html) for connection warming and details.

Want to avoid validators linked to sandwich attacks? Add [`mev-protect=true`](/content/docs/sending-transactions/mev-protect/index.html) 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](/content/docs/sending-transactions/sender#requirements/index.html)
- **Priority fee**: A compute unit price instruction via `ComputeBudgetProgram.setComputeUnitPrice`

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

- @solana/web3.js
- cURL

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

```bash
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](/content/docs/sending-transactions/sender-max/index.html) 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](/content/docs/sending-transactions/sender#connection-warming/index.html) during idle periods longer than 5 seconds.
- **Priority fees**: Use the [Helius Priority Fee API](/content/docs/priority-fee-api/index.html) for real-time recommendations.
- **Retries**: Set `maxRetries: 0` and implement your own retry logic.