> ## 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: transmisión de datos de Solana en tiempo real

> Transmite datos de Solana en tiempo real mediante LaserStream WebSocket: suscripciones estándar de Solana y extensiones de Helius como transactionSubscribe, con hasta 200 ms más de velocidad.

## ¿Qué es LaserStream WebSocket?

LaserStream WebSocket es la variante de [LaserStream](/docs/es/laserstream) basada en el protocolo WebSocket. Ofrece los métodos estándar de suscripción JSON-RPC de Solana (`accountSubscribe`, `programSubscribe`, `logsSubscribe`, `signatureSubscribe`, `slotSubscribe`, …) junto con extensiones específicas de Helius como [`transactionSubscribe`](/docs/es/rpc/websocket/transaction-subscribe) para aplicar filtros avanzados, todo en el mismo punto de conexión unificado `wss://mainnet.helius-rpc.com` y con la misma infraestructura de LaserStream que el [producto gRPC](/docs/es/laserstream).

WebSocket te proporciona una conexión persistente y en tiempo real: en lugar de consultar repetidamente «¿cambió algo?», la blockchain te notifica en cuanto ocurre algo.

<CardGroup cols={2}>
  <Card title="Real-Time Updates" icon="bolt">
    Recibe notificaciones instantáneas cuando cambien las cuentas de Solana, se produzcan transacciones o se generen bloques nuevos
  </Card>

  <Card title="Efficient Resource Usage" icon="leaf">
    Una conexión persistente en lugar de consultar mediante cientos de solicitudes HTTP
  </Card>

  <Card title="Low Latency" icon="clock">
    Hasta 200 ms más rápido que los WebSocket estándar basados en RPC de Agave, mediante LaserStream
  </Card>

  <Card title="Helius Extensions" icon="filter">
    `transactionSubscribe` y una versión mejorada de `accountSubscribe` para aplicar filtros avanzados además de los métodos estándar de Solana
  </Card>
</CardGroup>

## Puntos de conexión

Los WebSocket, tanto los métodos estándar de Solana como las extensiones específicas de Helius, están disponibles desde un único punto de conexión unificado por red:

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

### Gatekeeper (Beta)

Para probar nuestra opción de WebSocket más rápida, usa el nuevo punto de conexión de Gatekeeper (Beta):

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

## Precios y medición

El uso de WebSocket se mide a razón de **2 créditos por cada 0.1 MB** de datos transmitidos sin comprimir. Abrir una conexión cuesta **1 crédito**.

Para cargas de trabajo de gran volumen con planes Professional, los [**complementos de datos**](/docs/es/billing/plans#complementos-de-datos) ofrecen asignaciones mensuales de datos (5 TB–100 TB) a costos predecibles. Los complementos de datos pueden aplicarse a LaserStream y WebSocket.

<Note>
  Los métodos específicos de Helius `transactionSubscribe` e `accountSubscribe` (con filtros de Helius) requieren un [plan](/docs/es/billing/plans) **Developer**, **Business** o **Professional**. Los métodos estándar de Solana como `programSubscribe`, `logsSubscribe` e `signatureSubscribe` están disponibles en todos los planes.
</Note>

## Conceptos principales

### Tipos de suscripción

<AccordionGroup>
  <Accordion title="Account Subscriptions" icon="user">
    Supervisa los cambios en cuentas específicas, como saldos de billeteras, cuentas de tokens o datos de programas.

    **Casos de uso:**

    * Seguimiento del saldo de billeteras
    * Supervisión de cuentas de tokens
    * Cambios de estado en contratos inteligentes
    * Actualizaciones de propiedad de NFT
  </Accordion>

  <Accordion title="Program Subscriptions" icon="code">
    Observa todas las cuentas pertenecientes a un programa específico para detectar cualquier cambio.

    **Casos de uso:**

    * Supervisión de operaciones en DEX
    * Seguimiento de protocolos DeFi
    * Actividad de mercados de NFT
    * Cambios en activos de juegos
  </Accordion>

  <Accordion title="Transaction Subscriptions" icon="receipt">
    Recibe notificaciones cuando se confirmen transacciones específicas o cuando las transacciones mencionen determinadas cuentas.

    **Casos de uso:**

    * Confirmaciones de pagos
    * Seguimiento del estado de transacciones
    * Aprobaciones multifirma
    * Supervisión de la ejecución de contratos
  </Accordion>

  <Accordion title="Slot Subscriptions" icon="clock">
    Supervisa el avance y la finalidad de la blockchain a nivel de slot.

    **Casos de uso:**

    * Aplicaciones de exploración de bloques
    * Supervisión del estado de la red
    * Seguimiento del consenso
    * Análisis de rendimiento
  </Accordion>
</AccordionGroup>

### Niveles de compromiso

Comprender los niveles de compromiso es fundamental para crear aplicaciones confiables:

<Tabs>
  <Tab title="Processed">
    **Más rápido** - Un validador procesó la transacción, pero aún no está confirmada

    * Latencia: \~400 ms
    * Riesgo: Puede descartarse o reordenarse
    * Úsalo para: Actualizaciones de la interfaz de usuario en tiempo real (con precaución)
  </Tab>

  <Tab title="Confirmed">
    **Equilibrado** - La mayoría del clúster votó por el slot

    * Latencia: \~2-3 segundos
    * Riesgo: Baja probabilidad de que se descarte
    * Úsalo para: La mayoría de las aplicaciones
  </Tab>

  <Tab title="Finalized">
    **Más seguro** - Una supermayoría del clúster votó por el slot

    * Latencia: \~15-30 segundos
    * Riesgo: Es extremadamente improbable que se descarte
    * Úsalo para: Aplicaciones financieras y transacciones de alto valor
  </Tab>
</Tabs>

<Info>
  **¿Quieres obtener más información sobre los niveles de compromiso?** Lee nuestra completa publicación del blog: [Cómo comprender los niveles de compromiso de Solana](https://www.helius.dev/blog/solana-commitment-levels)
</Info>

## Métodos WebSocket disponibles

Helius admite el conjunto completo de métodos de suscripción WebSocket de Solana, además de extensiones específicas de Helius. Todos los métodos comparten el mismo punto de conexión `wss://mainnet.helius-rpc.com`.

### Extensiones de Helius

Dos métodos ofrecen filtros más completos que el estándar de Solana:

* [`transactionSubscribe`](/docs/es/rpc/websocket/transaction-subscribe) — suscríbete a transacciones que coincidan con listas de cuentas incluidas, excluidas u obligatorias, indicadores de voto o fallo y una firma específica
* [`accountSubscribe`](/docs/es/rpc/websocket/account-subscribe) — Helius agrega filtros avanzados a la estructura estándar de `accountSubscribe`

### Métodos estándar de Solana

`accountSubscribe`, `blockSubscribe`, `logsSubscribe`, `programSubscribe`, `rootSubscribe`, `signatureSubscribe`, `slotSubscribe`, `slotsUpdatesSubscribe`, `voteSubscribe` y sus pares `*Unsubscribe` correspondientes.

<Card title="Complete API Reference" icon="book" href="/docs/es/api-reference/rpc/websocket-methods">
  **Explora los más de 18 métodos WebSocket**. Cada método incluye parámetros detallados, formatos de respuesta y ejemplos.
</Card>

## Cómo implementar la lógica de reconexión

Las conexiones WebSocket pueden interrumpirse por varios motivos: problemas de red, mantenimiento del servidor o interrupciones temporales. Las aplicaciones de producción **deben** implementar una lógica de reconexión para garantizar la confiabilidad.

### Por qué se producen las desconexiones

<AccordionGroup>
  <Accordion title="Network Issues">
    * Problemas de conectividad a Internet
    * Cambios de red Wi-Fi en dispositivos móviles
    * Tiempos de espera del firewall corporativo
    * Cambios de enrutamiento del proveedor de Internet
  </Accordion>

  <Accordion title="Server-Side Events">
    * Periodos de mantenimiento programado
    * Reinicios del balanceador de carga
    * Actualizaciones de nodos RPC
    * Protección temporal contra sobrecargas
  </Accordion>

  <Accordion title="Client-Side Issues">
    * Pestañas del navegador en segundo plano
    * Suspensión de aplicaciones móviles
    * Suspensión o hibernación de la computadora
    * Fallos o reinicios de procesos
  </Accordion>
</AccordionGroup>

### Cómo detectar desconexiones

<Tabs>
  <Tab title="JavaScript/Browser">
    ```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>

### Estrategias de reconexión

<Tabs>
  <Tab title="Exponential Backoff">
    ```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="Circuit Breaker Pattern">
    ```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>

### Cómo probar la lógica de reconexión

<Tabs>
  <Tab title="Network Simulation">
    ```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="Automated Testing">
    ```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>
  **Crítico para producción**: Implementar una lógica de reconexión adecuada no es opcional para las aplicaciones de producción. Las conexiones WebSocket se interrumpirán: prepárate para ello, pruébalo y supervísalo en producción.
</Warning>

## Solución de problemas

<AccordionGroup>
  <Accordion title="Connection Failed">
    **Síntomas**: WebSocket no puede establecer la conexión inicial

    **Soluciones**:

    * Verifica que tu clave de API sea correcta y tenga créditos suficientes
    * Comprueba el formato de la URL del punto de conexión: `wss://mainnet.helius-rpc.com?api-key=YOUR_KEY`
    * Asegúrate de que tu firewall permita conexiones WebSocket en el puerto 443
    * Primero, prueba con un ping sencillo para verificar la conectividad básica
  </Accordion>

  <Accordion title="Frequent Disconnections">
    **Síntomas**: La conexión se interrumpe cada pocos minutos

    **Soluciones**:

    * Los WebSocket tienen un **temporizador de inactividad de 10 minutos**. Envía un ping al menos una vez por minuto para mantener activa la conexión (consulta los ejemplos de reconexión anteriores y las [preguntas frecuentes sobre WebSocket](/docs/es/faqs/websockets#desconexiones-y-reintentos))
    * Implementa correctamente el latido ping/pong (como se muestra en los ejemplos de reconexión anteriores)
    * Comprueba la estabilidad de tu red y la configuración del firewall corporativo
    * Supervisa la cantidad de suscripciones; un exceso puede causar inestabilidad
    * Verifica que gestiones correctamente el ciclo de vida de la conexión
  </Accordion>

  <Accordion title="Missing Messages">
    **Síntomas**: No se reciben las actualizaciones de suscripción esperadas

    **Soluciones**:

    * Verifica que tu suscripción esté confirmada (revisa la respuesta)
    * Asegúrate de que la cuenta o el programa que supervisas tenga actividad real
    * Supervisa el estado de tu conexión; los mensajes perdidos suelen indicar desconexiones
  </Accordion>

  <Accordion title="High Latency">
    **Síntomas**: Entrega lenta de mensajes y retrasos en las actualizaciones

    **Soluciones**:

    * Usa el nivel de compromiso "confirmed" en lugar de "finalized"
    * Reduce la cantidad de suscripciones activas
    * Optimiza tu lógica de procesamiento de mensajes
    * Considera usar varias conexiones para distribuir la carga
    * Comprueba la calidad de tu conexión de red
  </Accordion>

  <Accordion title="Memory Leaks">
    **Síntomas**: El uso de memoria de la aplicación aumenta con el tiempo

    **Soluciones**:

    * Implementa una limpieza adecuada de las suscripciones
    * Elimina los escuchadores de eventos cuando se desmonten los componentes
    * Borra periódicamente los registros de mensajes
    * Supervisa la cantidad de suscripciones y aplica límites
    * Usa referencias débiles para las funciones de callback cuando sea posible
  </Accordion>
</AccordionGroup>

## Migración desde RPC estándar

Si actualmente usas consultas periódicas mediante HTTP, sigue este proceso para migrar a WebSocket:

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

## Capacidades mejoradas

Para aplicaciones que requieren funciones aún más avanzadas, considera usar [LaserStream gRPC](/docs/es/laserstream):

<CardGroup cols={2}>
  <Card title="24-Hour Historical Replay" icon="clock-rotate-left">
    Recupera los datos que no recibiste mientras tu aplicación estaba desconectada
  </Card>

  <Card title="Multi-Node Aggregation" icon="network-wired">
    Obtén mayor confiabilidad mediante datos de varios validadores
  </Card>

  <Card title="Higher Throughput" icon="gauge-high">
    Gestiona más suscripciones y tasas de mensajes más altas
  </Card>

  <Card title="Enterprise Features" icon="building">
    Supervisión, análisis y canalizaciones de datos avanzados
  </Card>
</CardGroup>

## Comienza

¿Todo listo para comenzar?

Consulta nuestra [guía de inicio rápido de WebSocket](/docs/es/rpc/websocket/quickstart) para ver ejemplos prácticos y una implementación paso a paso.

## Guías

Encontrarás tutoriales paso a paso con código ejecutable en la página de [guías de LaserStream WebSocket](/docs/es/rpc/websocket/guides).