> ## 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 : Envoi à faible latence optimisé pour le coût

> Envoyez des transactions Solana via le chemin SWQOS-only optimisé pour le coût du Sender de Helius avec un pourboire minimum de 0,000005 SOL. Faible latence au pourboire le plus bas.

## Vue d'ensemble

SWQOS-only est le niveau [Helius Sender](/docs/fr/sending-transactions/sender) optimisé pour le coût. Il achemine votre transaction via un seul chemin SWQOS (qualité de service pondérée par le stake) rapide avec le **plus faible pourboire minimum de tous les niveaux Sender : 0,000005 SOL**.

Utilisez ce niveau lorsque vous souhaitez un envoi à faible latence au pourboire le plus bas. Pour les transactions très disputées où l'atterrissage le plus rapide importe, utilisez plutôt le niveau [Sender Max](/docs/fr/sending-transactions/sender-max).

<CardGroup cols={2}>
  <Card title="Pourboire le plus bas" icon="dollar-sign">
    Pourboire minimum de seulement 0,000005 SOL — la manière la moins chère d'utiliser Sender
  </Card>

  <Card title="Chemin unique rapide" icon="bolt">
    Acheminé exclusivement via l'infrastructure SWQOS pour une livraison à faible latence
  </Card>

  <Card title="Pas de crédits" icon="coins">
    Disponible sur tous les plans sans consommer de crédits API
  </Card>

  <Card title="Itinéraire unique" icon="circle-info">
    Acheminé seulement à travers un chemin SWQOS — pour un acheminement multipath et l'atterrissage le plus rapide, utilisez le niveau Sender Max
  </Card>
</CardGroup>

## Quand utiliser SWQOS-only

<CardGroup cols={2}>
  <Card title="Bonne compatibilité" icon="circle-check">
    Trading sensible aux coûts, volume de transactions élevé et flots où un
    seul chemin rapide suffit pour atterrir de manière fiable.
  </Card>

  <Card title="Envisagez plutôt Sender Max" icon="trophy" href="/docs/fr/sending-transactions/sender-max">
    Comptes très disputés, lancements compétitifs ou toute transaction où
    vous avez besoin de l'atterrissage le plus rapide possible.
  </Card>
</CardGroup>

## Comment activer SWQOS-only

Ajoutez le paramètre de requête `swqos_only=true` à toute URL de point de terminaison Sender. Utilisez le point de terminaison HTTPS global pour les frontends, ou le point de terminaison HTTP régional le plus proche de vos serveurs pour les backends.

**Frontend / navigateur (HTTPS global) :**

```
https://sender.helius-rpc.com/fast?swqos_only=true
```

**Backend / serveur (HTTP régional) :**

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

Ceci achemine votre transaction exclusivement via SWQOS et applique l'exigence de pourboire minimum plus faible de **0,000005 SOL**. Voir la [référence des points de terminaison Sender](/docs/fr/sending-transactions/sender#points-daccès) pour le réchauffement de la connexion et les détails.

<Tip>
  Vous souhaitez éviter les validateurs liés aux attaques sandwich ? Ajoutez
  [`mev-protect=true`](/docs/fr/sending-transactions/mev-protect) en plus de `swqos_only` :
  `https://sender.helius-rpc.com/fast?swqos_only=true&mev-protect=true`.
</Tip>

## Exigences

Comme chaque niveau Sender, les transactions SWQOS-only doivent inclure :

* **Pourboire** : Un transfert de SOL d'au moins **0,000005 SOL** vers un [compte de pourboire](/docs/fr/sending-transactions/sender#exigences) désigné
* **Frais de priorité** : Une instruction de prix des unités de calcul via `ComputeBudgetProgram.setComputeUnitPrice`

Sauter le préflight (`skipPreflight: true`) est optionnel mais recommandé — Les vérifications préflight augmentent la latence.

<Warning>
  Votre transaction doit contenir à la fois un transfert de pourboire et une instruction de prix des unités de calcul. Sans les deux, elle sera rejetée.
</Warning>

## Exemple de code

<Tabs>
  <Tab title="@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>

  <Tab title="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
          }
        ]
      }'
    ```
  </Tab>
</Tabs>

<Note>
  La transaction ci-dessus utilise toujours un pourboire de 0,000005 SOL — le minimum SWQOS-only.
  Les pourboires entre 0,000005 SOL et 0,001 SOL sont acceptés mais restent sur le chemin unique SWQOS. Pour acheminer à travers chaque itinéraire pour l'atterrissage le plus rapide, utilisez le niveau
  [Sender Max](/docs/fr/sending-transactions/sender-max) avec un pourboire minimum de 0,001 SOL.
</Note>

## Bonnes pratiques

* **Sélection du point de terminaison** : Utilisez `https://sender.helius-rpc.com/fast?swqos_only=true` pour les applications frontend afin d'éviter les problèmes CORS. Pour les applications backend, utilisez le point de terminaison HTTP régional le plus proche de vos serveurs.
* **Réchauffement de la connexion** : Utilisez le [point de terminaison `/ping`](/docs/fr/sending-transactions/sender#réchauffement-de-connexion) pendant les périodes d'inactivité de plus de 5 secondes.
* **Frais de priorité** : Utilisez l'[API Helius Priority Fee](/docs/fr/priority-fee-api) pour des recommandations en temps réel.
* **Réessayages** : Configurez `maxRetries: 0` et implémentez votre propre logique de réessai.

## Connexes

<CardGroup cols={2}>
  <Card title="Aperçu du Sender" icon="rocket" href="/docs/fr/sending-transactions/sender">
    Concepts partagés : points de terminaison, réchauffement de la connexion, limites de taux, et TPS personnalisé.
  </Card>

  <Card title="Niveau Sender Max" icon="trophy" href="/docs/fr/sending-transactions/sender-max">
    L'atterrissage le plus rapide via un acheminement multipath à travers tous les itinéraires (pourboire min de 0,001 SOL).
  </Card>

  <Card title="Remboursements de transactions" icon="coins" href="/docs/fr/sending-transactions/backrun-rebates">
    Optez pour gagner une part du MEV créé par vos transactions, payé en SOL.
  </Card>

  <Card title="Protection MEV" icon="shield-halved" href="/docs/fr/sending-transactions/mev-protect">
    Évitez les validateurs statistiquement liés aux attaques sandwich.
  </Card>
</CardGroup>