WebSockets vs Server-Sent Events vs Polling: Cuándo usar cada uno

Introducción

¿Alguna vez te preguntaste cómo funcionan las notificaciones en tiempo real en aplicaciones web? ¿Cómo sabe tu app que llegó un nuevo mensaje sin que tengas que recargar la página?

La respuesta está en tres tecnologías: Polling, Server-Sent Events (SSE) y WebSockets. Cada una tiene sus fortalezas, debilidades y casos de uso ideales.

En este post te explico cada una, cuándo usarlas, y cómo implementarlas con ejemplos prácticos.

¿Qué es Polling?

Polling es la forma más simple de obtener datos del servidor: el cliente pregunta “¿hay algo nuevo?” cada X segundos.

// Polling básico cada 5 segundos
setInterval(async () => {
  const response = await fetch('/api/notifications');
  const data = await response.json();
  updateUI(data);
}, 5000);

Ventajas:

• Simple de implementar
• Funciona en cualquier servidor
• Compatible con todos los navegadores

Desventajas:

• Ineficiente: muchas requests innecesarias
• Latencia: hasta X segundos de retraso
• Consume recursos del servidor innecesariamente

Cuándo usarlo:

• Prototipos rápidos
• Aplicaciones con pocos usuarios
• Cuando la latencia de segundos es aceptable

¿Qué es Server-Sent Events (SSE)?

SSE permite al servidor enviar datos al cliente de forma unidireccional (servidor → cliente) a través de una conexión HTTP persistente.

// Cliente SSE
const eventSource = new EventSource('/api/notifications/stream');

eventSource.onmessage = (event) => {
  const data = JSON.parse(event.data);
  updateUI(data);
};

eventSource.onerror = () => {
  console.log('Reconectando...');
};

# Servidor SSE (Python/Flask)
from flask import Response
import json, time

@app.route('/api/notifications/stream')
def stream():
    def event_stream():
        while True:
            data = get_new_notifications()
            if data:
                yield f"data: {json.dumps(data)}\n\n"
            time.sleep(1)
    
    return Response(event_stream(), mimetype='text/event-stream')

Ventajas:

• Conexión persistente (menos overhead que polling)
• Reconexión automática nativa
• Simple de implementar (basado en HTTP)
• Eficiente para datos unidireccionales

Desventajas:

• Solo servidor → cliente (no bidireccional)
• Límite de conexiones simultáneas en algunos navegadores
• No soporta datos binarios

Cuándo usarlo:

• Notificaciones en tiempo real
• Feeds de noticias o actualizaciones
• Dashboards con datos que cambian frecuentemente

¿Qué son WebSockets?

WebSockets proporcionan una conexión bidireccional full-duplex entre cliente y servidor a través de una única conexión TCP.

// Cliente WebSocket
const socket = new WebSocket('wss://api.ejemplo.com/notifications');

socket.onopen = () => {
  console.log('Conectado');
  socket.send(JSON.stringify({ action: 'subscribe', channel: 'notifications' }));
};

socket.onmessage = (event) => {
  const data = JSON.parse(event.data);
  updateUI(data);
};

# Servidor WebSocket (Python/websockets)
import asyncio, json, websockets

async def handler(websocket):
    async for message in websocket:
        data = json.loads(message)
        if data['action'] == 'subscribe':
            await subscribe(websocket, data['channel'])

async def main():
    async with websockets.serve(handler, "localhost", 8765):
        await asyncio.Future()

asyncio.run(main())

Ventajas:

• Bidireccional: cliente y servidor pueden enviar datos en cualquier momento
• Baja latencia
• Eficiente: una conexión persistente
• Soporta texto y binarios

Desventajas:

• Más complejo de implementar
• Requiere servidor compatible con WebSockets
• Puede ser excesivo para casos simples

Cuándo usarlo:

• Chat en tiempo real
• Juegos online
• Aplicaciones colaborativas (editores, whiteboards)

Comparación directa

Aspecto	Polling	SSE	WebSockets
Dirección	Cliente → Servidor	Servidor → Cliente	Bidireccional
Latencia	Alta (segundos)	Baja	Muy baja
Complejidad	Baja	Media	Alta
Eficiencia	Baja	Alta	Muy alta
Reconexión	Manual	Automática	Manual
Caso ideal	Prototipos	Notificaciones	Chat, juegos

¿Cuál elegir?

La respuesta depende de tu caso de uso:

1. Polling → Prototipos, apps simples, cuando la latencia no importa

2. SSE → Notificaciones, feeds, dashboards (servidor → cliente)

3. WebSockets → Chat, juegos, apps colaborativas (bidireccional)

Conclusión

No hay una tecnología “mejor” en absoluto. Cada una resuelve un problema específico:

• Polling para simplicidad
• SSE para notificaciones unidireccionales
• WebSockets para comunicación bidireccional en tiempo real

Elegir la herramienta correcta para tu caso de uso es lo que marca la diferencia entre una app que funciona y