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

# LaserStream WebSocket : Diffusion de données Solana en temps réel

> Diffusez des données Solana en temps réel via LaserStream WebSocket — abonnements Solana standard plus extensions Helius comme transactionSubscribe, jusqu'à 200 ms plus rapide.

## Qu'est-ce que LaserStream WebSocket ?

LaserStream WebSocket est la variante du protocole WebSocket de [LaserStream](/docs/fr/laserstream). Il sert les méthodes d'abonnement JSON-RPC standard de Solana (`accountSubscribe`, `programSubscribe`, `logsSubscribe`, `signatureSubscribe`, `slotSubscribe`, …) ainsi que des extensions spécifiques à Helius comme [`transactionSubscribe`](/docs/fr/rpc/websocket/transaction-subscribe) pour un filtrage avancé — le tout sur le même point de terminaison unifié `wss://mainnet.helius-rpc.com` et sur le même backend LaserStream que le [produit gRPC](/docs/fr/laserstream).

Les WebSockets vous donnent une connexion persistante et en temps réel : au lieu de sonder à plusieurs reprises « quelque chose a-t-il changé ? », la blockchain vous avertit dès qu'il se passe quelque chose.

<CardGroup cols={2}>
  <Card title="Mises à jour en temps réel" icon="bolt">
    Soyez instantanément averti lorsque les comptes Solana changent, que des transactions ont lieu ou que de nouveaux blocs sont produits
  </Card>

  <Card title="Utilisation efficace des ressources" icon="leaf">
    Une connexion persistante au lieu de sonder des centaines de requêtes HTTP
  </Card>

  <Card title="Faible latence" icon="clock">
    Jusqu'à 200 ms plus rapide que les WebSockets standard basés sur Agave RPC, servis par LaserStream
  </Card>

  <Card title="Extensions Helius" icon="filter">
    `transactionSubscribe` et un `accountSubscribe` amélioré pour un filtrage avancé au-dessus des méthodes standard Solana
  </Card>
</CardGroup>

## Points de terminaison

Les WebSockets — à la fois les méthodes standard de Solana et les extensions spécifiques à Helius — sont servis à partir d'un seul point de terminaison unifié par réseau :

**Mainnet :** `wss://mainnet.helius-rpc.com/?api-key=<API_KEY>`
**Devnet :** `wss://devnet.helius-rpc.com/?api-key=<API_KEY>`

### Gatekeeper (Bêta)

Pour tester notre offre WebSocket la plus rapide, essayez le nouveau point de terminaison Gatekeeper (Bêta) :

`wss://beta.helius-rpc.com/?api-key=<API_KEY>`

## Tarification et mesure

L'utilisation des WebSockets est mesurée à **2 crédits par 0,1 MB** de données diffusées non compressées. Ouvrir une connexion coûte **1 crédit**.

Pour des charges de travail à haut volume sur les plans Professionnels, [**Add-ons de données**](/docs/fr/billing/plans#extensions-de-données) offrent des allocations mensuelles de données (5TB–100TB) à des coûts prévisibles. Les add-ons de données peuvent être appliqués à LaserStream et aux WebSockets.

<Note>
  Les méthodes spécifiques à Helius `transactionSubscribe` et `accountSubscribe` (avec des filtres Helius) nécessitent un [plan](/docs/fr/billing/plans) **Développeur**, **Entreprise** ou **Professionnel**. Les méthodes standard de Solana comme `programSubscribe`, `logsSubscribe`, et `signatureSubscribe` sont disponibles sur tous les plans.
</Note>

## Concepts de base

### Types d'abonnement

<AccordionGroup>
  <Accordion title="Abonnements aux comptes" icon="user">
    Surveillez les changements sur des comptes spécifiques comme les soldes de portefeuilles, les comptes de tokens ou les données des programmes.

    **Cas d'utilisation :**

    * Suivi des soldes de portefeuille
    * Surveillance des comptes de tokens
    * Changements d'état des smart contracts
    * Mises à jour de la propriété des NFT
  </Accordion>

  <Accordion title="Abonnements aux programmes" icon="code">
    Surveillez tous les comptes détenus par un programme spécifique pour détecter tout changement.

    **Cas d'utilisation :**

    * Surveillance des échanges DEX
    * Suivi des protocoles DeFi
    * Activité sur les marchés NFT
    * Changements d'actifs dans les jeux
  </Accordion>

  <Accordion title="Abonnements aux transactions" icon="receipt">
    Recevez une notification lorsque des transactions spécifiques sont confirmées ou lorsque des transactions mentionnent certains comptes.

    **Cas d'utilisation :**

    * Confirmations de paiement
    * Suivi du statut des transactions
    * Approbations multi-signatures
    * Surveillance de l'exécution des contrats
  </Accordion>

  <Accordion title="Abonnements aux slots" icon="clock">
    Surveillez la progression de la blockchain et la finalité au niveau des slots.

    **Cas d'utilisation :**

    * Applications d'exploration de blocs
    * Surveillance de la santé du réseau
    * Suivi du consensus
    * Analyses de performance
  </Accordion>
</AccordionGroup>

### Niveaux d'engagement

Comprendre les niveaux d'engagement est crucial pour des applications fiables :

<Tabs>
  <Tab title="Traitée">
    **La plus rapide** - Transaction traitée par un validateur mais non confirmée

    * Latence : \~400ms
    * Risque : Peut être abandonnée ou réorganisée
    * Utilisation : Mises à jour d’interface en temps réel (avec prudence)
  </Tab>

  <Tab title="Confirmée">
    **Équilibrée** - La majorité du cluster a voté sur le slot

    * Latence : \~2-3 secondes
    * Risque : Faible chance d'être abandonnée
    * Utilisation : La plupart des applications
  </Tab>

  <Tab title="Finalisée">
    **La plus sûre** - Une supermajorité du cluster a voté sur le slot

    * Latence : \~15-30 secondes
    * Risque : Extrêmement improbable d'être abandonnée
    * Utilisation : Applications financières, transactions de haute valeur
  </Tab>
</Tabs>

<Info>
  **Vous voulez en savoir plus sur les niveaux d'engagement ?** Lisez notre article de blog complet : [Comprendre les niveaux d'engagement de Solana](https://www.helius.dev/blog/solana-commitment-levels)
</Info>

## Méthodes WebSocket disponibles

Helius prend en charge l'ensemble complet des méthodes d'abonnement WebSocket Solana, plus des extensions spécifiques à Helius. Toutes les méthodes partagent le même point de terminaison `wss://mainnet.helius-rpc.com`.

### Extensions Helius

Deux méthodes offrent un filtrage plus riche que la norme Solana :

* [`transactionSubscribe`](/docs/fr/rpc/websocket/transaction-subscribe) — s'abonner aux transactions correspondant aux listes de comptes à inclure/exclure/requis, indicateurs de vote/échec, et une signature spécifique
* [`accountSubscribe`](/docs/fr/rpc/websocket/account-subscribe) — Helius ajoute des filtres avancés au-dessus de la forme standard `accountSubscribe`

### Méthodes standard Solana

`accountSubscribe`, `blockSubscribe`, `logsSubscribe`, `programSubscribe`, `rootSubscribe`, `signatureSubscribe`, `slotSubscribe`, `slotsUpdatesSubscribe`, `voteSubscribe` et leurs paires correspondantes `*Unsubscribe`.

<Card title="Référence API complète" icon="book" href="/docs/fr/api-reference/rpc/websocket-methods">
  **Explorez les 18+ méthodes WebSocket**. Chaque méthode inclut des paramètres détaillés, des formats de réponse et des exemples.
</Card>

## Comment implémenter la logique de reconnexion

Les connexions WebSocket peuvent être déconnectées pour diverses raisons - problèmes de réseau, maintenance du serveur ou pannes temporaires. Les applications en production **doivent** implémenter une logique de reconnexion pour garantir la fiabilité.

### Pourquoi les déconnexions se produisent

<AccordionGroup>
  <Accordion title="Problèmes de réseau">
    * Problèmes de connectivité Internet
    * Transferts WiFi sur les appareils mobiles
    * Expirations de pare-feu d'entreprise
    * Changements de routage ISP
  </Accordion>

  <Accordion title="Événements côté serveur">
    * Fenêtres de maintenance planifiées
    * Redémarrages de l'équilibreur de charge
    * Mises à jour des nœuds RPC
    * Protection contre la surcharge temporaire
  </Accordion>

  <Accordion title="Problèmes côté client">
    * Onglet de navigateur en arrière-plan
    * Suspension de l'application mobile
    * Veille/hibernation de l'ordinateur
    * Plantages ou redémarrages de processus
  </Accordion>
</AccordionGroup>

### Détection des déconnexions

<Tabs>
  <Tab title="JavaScript/Navigateur">
    ```javascript [expandable] theme={"system"}
    class ConnectionMonitor {
      constructor(ws) {
        this.ws = ws;
        this.pingInterval = null;
        this.lastPong = Date.now();
        this.isConnected = false;
        
        this.setupEventListeners();
        this.startPingMonitoring();
      }
      
      setupEventListeners() {
        this.ws.onopen = () => {
          console.log('Connected');
          this.isConnected = true;
          this.lastPong = Date.now();
        };
        
        this.ws.onclose = (event) => {
          console.log('Disconnected:', event.code, event.reason);
          this.isConnected = false;
          this.stopPingMonitoring();
        };
        
        this.ws.onerror = (error) => {
          console.error('WebSocket error:', error);
          this.isConnected = false;
        };
        
        // Listen for pong responses (server acknowledgment)
        this.ws.onmessage = (event) => {
          const data = JSON.parse(event.data);
          if (data.method === 'pong') {
            this.lastPong = Date.now();
          }
          // Handle other messages...
        };
      }
      
      startPingMonitoring() {
        this.pingInterval = setInterval(() => {
          if (this.isConnected) {
            // Send ping to check connection health
            this.ws.send(JSON.stringify({
              jsonrpc: '2.0',
              method: 'ping',
              id: Date.now()
            }));
            
            // Check if we received a pong recently
            const timeSinceLastPong = Date.now() - this.lastPong;
            if (timeSinceLastPong > 30000) { // 30 seconds timeout
              console.warn('No pong received, connection may be stale');
              this.ws.close();
            }
          }
        }, 10000); // Ping every 10 seconds
      }
      
      stopPingMonitoring() {
        if (this.pingInterval) {
          clearInterval(this.pingInterval);
          this.pingInterval = null;
        }
      }
    }
    ```
  </Tab>

  <Tab title="Node.js">
    ```javascript [expandable] theme={"system"}
    const WebSocket = require('ws');

    class NodeConnectionMonitor {
      constructor(url) {
        this.url = url;
        this.ws = null;
        this.pingInterval = null;
        this.isAlive = false;
      }
      
      connect() {
        this.ws = new WebSocket(this.url);
        
        this.ws.on('open', () => {
          console.log('Connected');
          this.isAlive = true;
          this.startHeartbeat();
        });
        
        this.ws.on('close', () => {
          console.log('Disconnected');
          this.isAlive = false;
          this.stopHeartbeat();
        });
        
        this.ws.on('error', (error) => {
          console.error('WebSocket error:', error);
          this.isAlive = false;
        });
        
        // Built-in ping/pong handling
        this.ws.on('pong', () => {
          this.isAlive = true;
        });
      }
      
      startHeartbeat() {
        this.pingInterval = setInterval(() => {
          if (!this.isAlive) {
            console.log('Connection lost, terminating');
            return this.ws.terminate();
          }
          
          this.isAlive = false;
          this.ws.ping();
        }, 30000); // Ping every 30 seconds
      }
      
      stopHeartbeat() {
        if (this.pingInterval) {
          clearInterval(this.pingInterval);
          this.pingInterval = null;
        }
      }
    }
    ```
  </Tab>
</Tabs>

### Stratégies de reconnexion

<Tabs>
  <Tab title="Backoff exponentiel">
    ```javascript [expandable] theme={"system"}
    class ExponentialBackoffReconnector {
      constructor(url, maxRetries = 10) {
        this.url = url;
        this.maxRetries = maxRetries;
        this.retryCount = 0;
        this.baseDelay = 1000; // Start with 1 second
        this.maxDelay = 30000; // Cap at 30 seconds
        this.ws = null;
        this.subscriptions = new Map();
        this.isReconnecting = false;
      }
      
      connect() {
        if (this.isReconnecting) return;
        
        try {
          this.ws = new WebSocket(this.url);
          this.setupEventHandlers();
        } catch (error) {
          console.error('Failed to create WebSocket:', error);
          this.scheduleReconnect();
        }
      }
      
      setupEventHandlers() {
        this.ws.onopen = () => {
          console.log('Connected successfully');
          this.retryCount = 0; // Reset retry count on successful connection
          this.isReconnecting = false;
          this.resubscribeAll(); // Restore subscriptions
        };
        
        this.ws.onclose = (event) => {
          console.log('Connection closed:', event.code);
          if (!this.isReconnecting) {
            this.scheduleReconnect();
          }
        };
        
        this.ws.onerror = (error) => {
          console.error('WebSocket error:', error);
        };
      }
      
      scheduleReconnect() {
        if (this.retryCount >= this.maxRetries) {
          console.error('Max retry attempts reached. Giving up.');
          return;
        }
        
        this.isReconnecting = true;
        this.retryCount++;
        
        // Calculate delay with exponential backoff + jitter
        const delay = Math.min(
          this.baseDelay * Math.pow(2, this.retryCount - 1),
          this.maxDelay
        );
        
        // Add jitter to prevent thundering herd
        const jitteredDelay = delay + (Math.random() * 1000);
        
        console.log(`Reconnecting in ${jitteredDelay}ms (attempt ${this.retryCount}/${this.maxRetries})`);
        
        setTimeout(() => {
          this.connect();
        }, jitteredDelay);
      }
      
      subscribe(method, params, callback) {
        const id = this.generateId();
        this.subscriptions.set(id, { method, params, callback });
        
        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
          this.sendSubscription(id, method, params);
        }
        
        return id;
      }
      
      resubscribeAll() {
        console.log(`Restoring ${this.subscriptions.size} subscriptions`);
        for (const [id, sub] of this.subscriptions) {
          this.sendSubscription(id, sub.method, sub.params);
        }
      }
      
      sendSubscription(id, method, params) {
        this.ws.send(JSON.stringify({
          jsonrpc: '2.0',
          id: id,
          method: method,
          params: params
        }));
      }
      
      generateId() {
        return Date.now() + Math.random();
      }
    }
    ```
  </Tab>

  <Tab title="Modèle de disjoncteur">
    ```javascript [expandable] theme={"system"}
    class CircuitBreakerWebSocket {
      constructor(url, options = {}) {
        this.url = url;
        this.failureThreshold = options.failureThreshold || 5;
        this.recoveryTimeout = options.recoveryTimeout || 60000;
        this.checkInterval = options.checkInterval || 10000;
        
        this.state = 'CLOSED'; // CLOSED, OPEN, HALF_OPEN
        this.failureCount = 0;
        this.lastFailureTime = null;
        this.ws = null;
        this.subscriptions = new Map();
      }
      
      connect() {
        if (this.state === 'OPEN') {
          if (Date.now() - this.lastFailureTime > this.recoveryTimeout) {
            console.log('Circuit breaker moving to HALF_OPEN state');
            this.state = 'HALF_OPEN';
          } else {
            console.log('Circuit breaker is OPEN, connection blocked');
            return false;
          }
        }
        
        try {
          this.ws = new WebSocket(this.url);
          this.setupEventHandlers();
          return true;
        } catch (error) {
          this.recordFailure();
          return false;
        }
      }
      
      setupEventHandlers() {
        this.ws.onopen = () => {
          console.log('Connected - Circuit breaker CLOSED');
          this.state = 'CLOSED';
          this.failureCount = 0;
          this.resubscribeAll();
        };
        
        this.ws.onclose = () => {
          this.recordFailure();
        };
        
        this.ws.onerror = (error) => {
          console.error('WebSocket error:', error);
          this.recordFailure();
        };
      }
      
      recordFailure() {
        this.failureCount++;
        this.lastFailureTime = Date.now();
        
        console.log(`Failure recorded: ${this.failureCount}/${this.failureThreshold}`);
        
        if (this.failureCount >= this.failureThreshold) {
          console.log('Circuit breaker opened due to repeated failures');
          this.state = 'OPEN';
        }
      }
      
      startHealthCheck() {
        setInterval(() => {
          if (this.state === 'OPEN' || 
              (this.ws && this.ws.readyState !== WebSocket.OPEN)) {
            this.connect();
          }
        }, this.checkInterval);
      }
    }
    ```
  </Tab>
</Tabs>

### Tester la logique de reconnexion

<Tabs>
  <Tab title="Simulation de réseau">
    ```javascript [expandable] theme={"system"}
    // Test disconnection scenarios
    class NetworkSimulator {
      constructor(wsManager) {
        this.wsManager = wsManager;
      }
      
      // Simulate network outage
      simulateNetworkOutage(duration = 5000) {
        console.log('Simulating network outage...');
        
        // Force close the connection
        if (this.wsManager.ws) {
          this.wsManager.ws.close(1006, 'Network outage simulation');
        }
        
        // Block reconnection temporarily
        const originalConnect = this.wsManager.connect.bind(this.wsManager);
        this.wsManager.connect = () => {
          console.log('Connection blocked during outage simulation');
        };
        
        // Restore connection after duration
        setTimeout(() => {
          console.log('Network restored');
          this.wsManager.connect = originalConnect;
          this.wsManager.connect();
        }, duration);
      }
      
      // Simulate intermittent connectivity
      simulateIntermittentConnectivity() {
        setInterval(() => {
          if (Math.random() < 0.1) { // 10% chance every 10 seconds
            console.log('Simulating connection drop...');
            this.wsManager.ws?.close(1006, 'Intermittent connectivity');
          }
        }, 10000);
      }
    }

    // Usage
    const simulator = new NetworkSimulator(wsManager);
    simulator.simulateNetworkOutage(10000); // 10 second outage
    ```
  </Tab>

  <Tab title="Tests automatisés">
    ```javascript [expandable] theme={"system"}
    // Jest test example
    describe('WebSocket Reconnection', () => {
      let wsManager;
      
      beforeEach(() => {
        wsManager = new ProductionWebSocketManager({
          endpoint: 'ws://localhost:8080',
          apiKey: 'test-key'
        });
      });
      
      test('should reconnect after connection loss', async () => {
        const reconnectPromise = new Promise((resolve) => {
          wsManager.on('connected', resolve);
        });
        
        await wsManager.connect();
        
        // Simulate connection loss
        wsManager.ws.close(1006, 'Test disconnection');
        
        // Wait for reconnection
        await reconnectPromise;
        
        expect(wsManager.connectionState).toBe('CONNECTED');
        expect(wsManager.metrics.reconnections).toBeGreaterThan(0);
      });
      
      test('should restore subscriptions after reconnection', async () => {
        await wsManager.connect();
        
        const messages = [];
        const subscriptionId = wsManager.subscribe(
          'accountSubscribe',
          ['test-account', {}],
          (data) => messages.push(data)
        );
        
        // Verify subscription exists
        expect(wsManager.subscriptions.has(subscriptionId)).toBe(true);
        
        // Simulate disconnection and reconnection
        wsManager.ws.close(1006, 'Test disconnection');
        
        await new Promise(resolve => wsManager.on('connected', resolve));
        
        // Verify subscription was restored
        const subscription = wsManager.subscriptions.get(subscriptionId);
        expect(subscription.pending).toBe(true); // Should be re-subscribing
      });
    });
    ```
  </Tab>
</Tabs>

<Warning>
  **Critique pour la production** : Implémenter une logique de reconnexion appropriée n'est pas optionnel pour les applications en production. Les connexions WebSocket se déconnecteront - prévoyez-le, testez-le et surveillez-le en production.
</Warning>

## Dépannage

<AccordionGroup>
  <Accordion title="Échec de connexion">
    **Symptômes** : WebSocket ne parvient pas à se connecter initialement

    **Solutions** :

    * Vérifiez que votre clé API est correcte et dispose de suffisamment de crédits
    * Vérifiez le format de l'URL de point de terminaison : `wss://mainnet.helius-rpc.com?api-key=YOUR_KEY`
    * Assurez-vous que votre pare-feu autorise les connexions WebSocket sur le port 443
    * Testez d'abord avec un simple ping pour vérifier la connectivité de base
  </Accordion>

  <Accordion title="Déconnexions fréquentes">
    **Symptômes** : La connexion tombe toutes les quelques minutes

    **Solutions** :

    * Les WebSockets ont une **minuterie d'inactivité de 10 minutes**. Envoyez un ping au moins une fois par minute pour garder la connexion active (voir les exemples de reconnexion ci-dessus et la [FAQ WebSocket](/docs/fr/faqs/websockets#déconnexions-et-réessais))
    * Implémentez un battement ping/pong approprié (comme montré dans les exemples de reconnexion ci-dessus)
    * Vérifiez la stabilité de votre réseau et les paramètres du pare-feu d'entreprise
    * Surveillez votre nombre d'abonnements - trop peuvent causer de l'instabilité
    * Vérifiez que vous gérez correctement le cycle de vie de la connexion
  </Accordion>

  <Accordion title="Messages manquants">
    **Symptômes** : Non réception des mises à jour d'abonnement attendues

    **Solutions** :

    * Vérifiez que votre abonnement est confirmé (vérifiez la réponse)
    * Assurez-vous que le compte/programme que vous surveillez a une activité réelle
    * Surveillez l'état de votre connexion - messages manqués indiquent souvent des déconnexions
  </Accordion>

  <Accordion title="Haute latence">
    **Symptômes** : Livraison lente des messages, retards dans les mises à jour

    **Solutions** :

    * Utilisez "confirmée" au lieu de "finalisée" comme engagement
    * Réduisez le nombre d'abonnements actifs
    * Optimisez votre logique de traitement des messages
    * Envisagez d'utiliser plusieurs connexions pour répartir la charge
    * Vérifiez la qualité de votre connexion réseau
  </Accordion>

  <Accordion title="Fuites de mémoire">
    **Symptômes** : L'utilisation de la mémoire de l'application augmente avec le temps

    **Solutions** :

    * Implémentez un nettoyage approprié des abonnements
    * Supprimez les écouteurs d'événements lorsque les composants sont démontés
    * Effacez les journaux de messages périodiquement
    * Surveillez le nombre d'abonnements et appliquez des limites
    * Utilisez des références faibles pour les fonctions de rappel lorsque cela est possible
  </Accordion>
</AccordionGroup>

## Migration depuis le RPC standard

Si vous utilisez actuellement le sondage HTTP, voici comment migrer vers les WebSockets :

```javascript [expandable] theme={"system"}
// Old approach - HTTP polling
class HTTPAccountMonitor {
  constructor(connection, accountAddress) {
    this.connection = connection;
    this.accountAddress = accountAddress;
    this.interval = null;
    this.lastKnownBalance = null;
  }

  start() {
    this.interval = setInterval(async () => {
      try {
        const accountInfo = await this.connection.getAccountInfo(
          new PublicKey(this.accountAddress)
        );
        
        const currentBalance = accountInfo?.lamports || 0;
        
        if (this.lastKnownBalance !== currentBalance) {
          console.log(`Balance changed: ${currentBalance}`);
          this.lastKnownBalance = currentBalance;
        }
      } catch (error) {
        console.error('Failed to fetch account info:', error);
      }
    }, 2000); // Poll every 2 seconds
  }

  stop() {
    if (this.interval) {
      clearInterval(this.interval);
      this.interval = null;
    }
  }
}

// New approach - WebSocket subscription
class WebSocketAccountMonitor {
  constructor(wsManager, accountAddress) {
    this.wsManager = wsManager;
    this.accountAddress = accountAddress;
    this.subscriptionId = null;
  }

  start() {
    this.subscriptionId = this.wsManager.subscribe(
      'accountSubscribe',
      [
        this.accountAddress,
        { encoding: 'jsonParsed', commitment: 'confirmed' }
      ],
      (data) => {
        const currentBalance = data.value.lamports;
        console.log(`Balance changed: ${currentBalance}`);
        
        // Handle the change immediately - no polling delay!
      }
    );
  }

  stop() {
    if (this.subscriptionId) {
      this.wsManager.unsubscribe(this.subscriptionId);
      this.subscriptionId = null;
    }
  }
}
```

## Capacités améliorées

Pour les applications nécessitant des fonctionnalités encore plus avancées, envisagez d'utiliser [LaserStream gRPC](/docs/fr/laserstream) :

<CardGroup cols={2}>
  <Card title="Relecture historique de 24 heures" icon="clock-rotate-left">
    Rattrapez les données manquées lorsque votre application était hors ligne
  </Card>

  <Card title="Agrégation multi-nœuds" icon="network-wired">
    Meilleure fiabilité via des données de plusieurs validateurs
  </Card>

  <Card title="Débit plus élevé" icon="gauge-high">
    Gérez plus d'abonnements et des taux de messages plus élevés
  </Card>

  <Card title="Fonctionnalités d'entreprise" icon="building">
    Surveillance avancée, analyses et pipelines de données
  </Card>
</CardGroup>

## Commencer

Prêt à commencer ?

Consultez notre [Guide de démarrage rapide WebSocket](/docs/fr/rpc/websocket/quickstart) pour des exemples pratiques et une implémentation étape par étape.

## Guides

Tutoriels étape par étape avec du code exécutable en direct sur la page [Guides LaserStream WebSocket](/docs/fr/rpc/websocket/guides).