> ## 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 : Soumission de transaction Solana à ultra-faible latence

> Soumission de transaction Solana à ultra-faible latence avec routage multi-chemins. Aucun crédit consommé, points d'accès globaux, optimisé pour le trading haute fréquence.

## Aperçu

<Note>
  **Mise à jour des tarifs :** Sender Max utilise désormais un pourboire minimum de **0.001 SOL**. Cela vous place dans un tampon de pourboires prioritaires pour le haut du bloc — donnez plus de pourboire pour être en premier. La catégorie optimisée pour le coût
  [SWQOS-seulement](/docs/fr/sending-transactions/sender-swqos-only) reste à 0.000005
  SOL.
</Note>

Helius Sender est un service spécialisé pour la soumission de transactions à ultra-faible latence, conçu pour le trading sensible à la latence. Il soumet votre transaction à travers tous les chemins (Helius, Jito, Harmonic, Rakurai, etc.) simultanément pour lui donner le chemin le plus rapide possible dans un bloc.

Sender **ne consomme pas de crédits API** — vous payez par transaction avec un pourboire en SOL. Il est disponible sur chaque plan, y compris le niveau gratuit.

<CardGroup cols={2}>
  <Card title="Pas de crédits" icon="coins">
    Disponible sur tous les plans sans consommer de crédits API. Vous payez par envoi avec
    un pourboire en SOL.
  </Card>

  <Card title="Routage Multi-Chemins" icon="arrows-split-up-and-left">
    Soumet à travers tous les chemins (Helius, Jito, Harmonic, Rakurai, etc.) pour l'inclusion la plus rapide possible
  </Card>

  <Card title="Points d'accès globaux" icon="globe">
    Le point d'accès HTTPS s'auto-route vers l'emplacement le plus proche pour le frontend, HTTP régional pour le backend
  </Card>

  <Card title="50 TPS (Par défaut)" icon="gauge-high" href="https://www.helius.dev/contact">
    Besoin de plus ? Demandez des limites plus élevées et des arrangements de pourboires personnalisés
  </Card>
</CardGroup>

## Choisissez votre catégorie

Sender propose deux catégories. Les deux sont à faible latence et sans crédits — la différence est le nombre de chemins que votre transaction emprunte et le pourboire minimum requis.

| Catégorie                                                     | Routage                          | Pourboire minimum | Tampon de pourboire | Idéal pour                                                                        |
| ------------------------------------------------------------- | -------------------------------- | ----------------- | ------------------- | --------------------------------------------------------------------------------- |
| [Sender Max](/docs/fr/sending-transactions/sender-max)             | Tous les chemins à haute vitesse | 0.001 SOL         | Oui                 | Transactions très contestées et paquets nécessitant l'atterrissage le plus rapide |
| [SWQOS-seulement](/docs/fr/sending-transactions/sender-swqos-only) | Chemin unique SWQOS              | 0.000005 SOL      | Non                 | Trading optimisé pour le coût sur un chemin rapide                                |

<Note>
  Les pourboires entre 0.000005 SOL et 0.001 SOL sont acceptés mais n'entrent pas dans le
  tampon de pourboires prioritaires — ils sont envoyés sur une base de meilleurs efforts à travers moins
  de chemins. Pour obtenir la priorité du tampon et chaque chemin de routage, donnez au moins 0.001
  SOL.
</Note>

<CardGroup cols={2}>
  <Card title="Sender Max (atterrissage le plus rapide)" icon="trophy" href="/docs/fr/sending-transactions/sender-max">
    Routé à travers chaque chemin et entré dans un tampon de pourboires prioritaires pour les
    soumissions les plus compétitives. Gère à la fois les transactions et les paquets.
  </Card>

  <Card title="SWQOS-seulement (optimisé pour le coût)" icon="dollar-sign" href="/docs/fr/sending-transactions/sender-swqos-only">
    Pourboire le plus bas, chemin rapide unique. Add `?swqos_only=true` to any endpoint URL.
  </Card>
</CardGroup>

## Guide de démarrage rapide

Prêt à soumettre votre première transaction Solana à ultra-faible latence ? Ce guide vous permet de commencer en quelques minutes. La meilleure partie : **vous n'avez besoin d'aucun plan payant ou accès spécial** — Sender est disponible pour tous les utilisateurs et ne consomme pas de crédits API.

L'exemple ci-dessous utilise le niveau [Sender Max](/docs/fr/sending-transactions/sender-max) (pourboire de 0.001 SOL). Pour l'option de pourboire la plus basse, voir [SWQOS-seulement](/docs/fr/sending-transactions/sender-swqos-only).

<Steps titleSize="h3">
  <Step title="Créez votre compte Helius gratuit">
    Commencez par créer votre compte gratuit sur le [Tableau de bord Helius](https://dashboard.helius.dev/dashboard). Sender est disponible sur tous les plans, y compris le niveau gratuit, et ne consomme aucun crédit API.
  </Step>

  <Step title="Obtenez votre clé API">
    Allez à la section [Clés API](https://dashboard.helius.dev/api-keys) et copiez votre clé. Utilisez-la pour obtenir les blockhashes et la confirmation de transaction. Sender gérera la soumission de la transaction.
  </Step>

  <Step title="Envoyez votre première transaction">
    Envoyons un simple transfert SOL en utilisant Sender. Cet exemple inclut le pourboire requis et la taxe de priorité, et saute les vérifications préalables pour une latence plus faible (optionnel).

    <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 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', {
            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>

      <Tab title="@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", {
            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');
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Succès ! Comprendre ce qui s'est passé">
    Vous avez soumis avec succès une transaction via Sender ! Voici ce qui a permis cela :

    * Aucun crédit consommé : Sender est sans crédit pour tous les utilisateurs
    * Routage multi-chemins : Votre transaction a été soumise à travers tous les chemins (Helius, Jito, Harmonic, Rakurai, etc.) simultanément
    * Pourboire requis : Un pourboire de 0.001 SOL entre dans le tampon de pourboires prioritaires et utilise chaque chemin de routage. Voir les [catégories](#choisissez-votre-catégorie) pour l'option à pourboire plus bas SWQOS-seulement
    * Taxe de priorité : Signale aux validateurs votre volonté de payer pour un traitement prioritaire
    * Pré-vérification sautée (optionnel) : Échange la validation contre la vitesse — Sender prend également en charge les vérifications préalables
  </Step>
</Steps>

## Exigences

<Warning>
  **Exigences obligatoires** : Chaque transaction de Sender doit inclure un pourboire
  (minimum 0.001 SOL pour [Sender Max](/docs/fr/sending-transactions/sender-max), ou
  0.000005 SOL pour [SWQOS-seulement](/docs/fr/sending-transactions/sender-swqos-only)) et une
  taxe de priorité.
</Warning>

<Note>
  `skipPreflight` est optionnel — Sender prend en charge les vérifications préalables. Définissez
  `skipPreflight: true` pour échanger la validation contre une latence inférieure.
</Note>

### Pourboires et taxes de priorité

Toutes les transactions soumises via Sender **doivent inclure à la fois un pourboire et une taxe de priorité** :

* **Pourboire** : Un transfert SOL vers un compte de pourboire désigné. Minimum 0.001 SOL pour Sender Max, ou 0.000005 SOL pour SWQOS-seulement.
* **Taxe de priorité** : Tarification des unités de calcul via `ComputeBudgetProgram.setComputeUnitPrice` pour prioriser votre transaction dans la file d'attente des validateurs.

<Accordion title="Comptes de pourboire désignés (mainnet-beta)">
  ```text theme={"system"}
  4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE
  D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ
  9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta
  5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn
  2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD
  2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ
  wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF
  3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT
  4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey
  4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or
  ```
</Accordion>

#### Pourquoi les deux sont nécessaires

* **Pourboires** : Vous donnent accès à tous les chemins de routage de Sender (Helius, Jito, Harmonic, Rakurai, etc.) et au tampon de pourboires prioritaires
* **Taxes de priorité** : Signalent aux validateurs votre volonté de payer pour un traitement prioritaire via le système de priorisation native de Solana
* **Ensemble** : Les pourboires maximisent les chemins que votre transaction peut emprunter, tandis que les taxes de priorité améliorent sa priorité auprès des validateurs — ensemble, ils maximisent la probabilité d'inclusion

Utilisez l'[API de taxe de priorité Helius](/docs/fr/priority-fee-api) pour des recommandations de taxes de priorité en temps réel.

## Points d'accès

Les points d'accès de Sender sont disponibles dans plusieurs configurations selon votre cas d'utilisation :

<Tabs>
  <Tab title="Applications Frontend/Navigateur">
    **Recommandé pour les applications frontend pour éviter les problèmes CORS :**

    ```
    https://sender.helius-rpc.com/fast   # Global HTTPS endpoint
    ```

    <Note>
      Le point d'accès HTTPS résout les échecs de pré-vérification CORS qui se produisent avec
      les applications basées sur navigateur lors de l'utilisation des points d'accès HTTP régionaux. Ce
      point d'accès s'auto-route automatiquement vers l'emplacement le plus proche pour des performances
      optimales. Utilisez cela pour les cas d'utilisation frontend/navigateur.
    </Note>
  </Tab>

  <Tab title="Applications Backend/Serveur">
    **Points d'accès HTTP régionaux pour une latence optimale de serveur à serveur :**

    ```
    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>
      Pour les applications backend/serveur, choisissez le point d'accès HTTP régional le plus proche
      de votre infrastructure pour des performances optimales.
    </Note>
  </Tab>

  <Tab title="Réchauffement de connexion">
    **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
    ```
  </Tab>
</Tabs>

## Réchauffement de connexion

Pour les applications avec de longues périodes entre les soumissions de transactions, utilisez le point d'accès de ping pour maintenir des connexions actives et réduire la latence de démarrage à froid.

Le point d'accès de ping accepte les requêtes GET simples et renvoie une réponse de base pour maintenir les connexions actives :

```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>
  Utilisez le réchauffement de connexion lorsque votre application a des écarts de plus de 5 secondes
  entre les transactions pour maintenir une latence de soumission optimale.
</Note>

## Format de requête

Sender accepte deux méthodes sur le même point d'accès. Chaque soumission doit inclure à la fois un pourboire et une taxe de priorité ; sauter la pré-vérification est optionnel (cela réduit la latence).

### sendTransaction

Soumettez une transaction unique. Elle doit contenir à la fois un transfert SOL avec le pourboire minimum vers un compte de pourboire désigné **et** une instruction de prix d'unité de calcul — sans les deux, elle sera rejetée.

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

Voir le [Démarrage rapide](#guide-de-démarrage-rapide) pour un exemple complet et exécutable `sendTransaction`.

### sendBundle

Soumettez jusqu'à 4 transactions entièrement signées pour une exécution atomique, tout-ou-rien. Au moins une transaction doit porter le pourboire.

```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" }
  ]
}
```

Voir [bundles Sender Max](/docs/fr/sending-transactions/sender-max#paquets) pour un exemple complet et comment suivre l'atterrissage.

### MEV Protect (optionnel)

Pour contourner les validateurs statistiquement liés aux attaques sandwich, ajoutez le paramètre de requête `mev-protect=true` à l'URL du point d'accès. Cela fonctionne sur les deux catégories de Sender et sur les deux `sendTransaction` et `sendBundle`, sans aucune modification de votre corps de requête.

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

Voir [MEV Protect](/docs/fr/sending-transactions/mev-protect) pour comprendre comment cela fonctionne et ses compromis.

<Card title="Référence API" icon="code" href="/docs/fr/api-reference/sender/sendtransaction">
  Voir la référence complète de l'API Sender avec les schémas de requête/réponse et
  les paramètres.
</Card>

## Limites de taux et mises à l'échelle

* **Limite de taux par défaut** : 50 transactions par seconde
* **Aucune utilisation de crédit** : Les transactions Sender ne consomment pas de crédits API de votre plan
* **Limites plus élevées** : Les utilisateurs du plan professionnel peuvent demander des augmentations significatives de la limite de taux pour prendre en charge les applications de trading à forte capacité

### TPS personnalisés avec authentification de clé API

<Note>
  Cette section est uniquement pertinente si vous avez obtenu des limites TPS augmentées
  et reçu une clé API de l'équipe Helius. Les utilisateurs standards peuvent ignorer cette
  section.
</Note>

Si vous avez été approuvé pour des limites TPS plus élevées, vous recevrez une clé API dédiée pour Sender. Pour l'utiliser, ajoutez la clé API en tant que paramètre de requête à l'URL de votre point d'accès :

<Tabs>
  <Tab title="Applications Frontend/Navigateur">
    ```
    https://sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>

  <Tab title="Applications Backend/Serveur">
    ```
    http://slc-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://ewr-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://lon-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://fra-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://ams-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://sg-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    http://tyo-sender.helius-rpc.com/fast?api-key=YOUR_SENDER_API_KEY
    ```
  </Tab>
</Tabs>

<Tip>
  Besoin de plus de 50 TPS ou d'un plan personnalisé ? [Demandez des limites
  plus élevées](https://www.helius.dev/contact) et explorez des arrangements de pourboires personnalisés
  pour Sender en contactant notre équipe commerciale.
</Tip>

## Support

Obtenez du support via le [Tableau de bord Helius](https://dashboard.helius.dev) ou rejoignez [Discord](https://discord.com/invite/6GXdee3gBj) pour obtenir de l'aide.

## Voir aussi : Livraison de Shred

[Shreds bruts (UDP)](/docs/fr/shred-delivery/raw-shreds) est notre livraison spécialisée de shreds Solana bruts via UDP, conçue pour vous donner un accès à ultra-faible latence aux données de transaction brutes de Solana.

En livrant des shreds non traités directement depuis le réseau, la Livraison de Shred offre un avantage concurrentiel pour les propAMMs, snipers, traders copiants, bots de liquidation, arbitrage, et les opérateurs de nœuds RPC qui souhaitent éliminer la latence de synchronisation du réseau.

<Tip>
  Commencez à recevoir des shreds bruts. [Abonnez-vous à la Livraison de Shred Helius](https://dashboard.helius.dev/shred-delivery-seats) dans votre tableau de bord.
</Tip>