WebSockets vs SSE vs Long Polling: Real-Time Communication Explained

# FastAPI long polling endpoint
import asyncio
from fastapi import FastAPI
from datetime import datetime
 
app = FastAPI()
pending_updates: dict[str, asyncio.Event] = {}
new_data: dict[str, list] = {}
 
@app.get("/updates/{client_id}")
async def get_updates(client_id: str):
    event = asyncio.Event()
    pending_updates[client_id] = event
    
    try:
        # Wait up to 30 seconds for new data
        await asyncio.wait_for(event.wait(), timeout=30)
        updates = new_data.pop(client_id, [])
        return {"updates": updates}
    except asyncio.TimeoutError:
        # No new data — client should reconnect
        return {"updates": []}
    finally:
        pending_updates.pop(client_id, None)
 
def push_update(client_id: str, data: dict):
    if client_id in pending_updates:
        new_data.setdefault(client_id, []).append(data)
        pending_updates[client_id].set()

// Client
async function pollForUpdates(clientId) {
  while (true) {
    const res = await fetch(`/updates/${clientId}`);
    const { updates } = await res.json();
    
    if (updates.length > 0) {
      handleUpdates(updates);
    }
    // Reconnects immediately after response
  }
}

import asyncio
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import json
 
app = FastAPI()
 
async def event_stream(channel: str):
    async for event in subscribe_to_channel(channel):
        # SSE format: "data: ...\n\n"
        yield f"data: {json.dumps(event)}\n\n"
        
        # Send keep-alive every 30s to prevent timeout
        if no_event_for_30s:
            yield ": keep-alive\n\n"
 
@app.get("/stream/{channel}")
async def stream_events(channel: str):
    return StreamingResponse(
        event_stream(channel),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # Disable Nginx buffering
        }
    )

// Client — built-in EventSource API
const es = new EventSource("/stream/trades");
 
es.onmessage = (event) => {
  const trade = JSON.parse(event.data);
  updateTradeDisplay(trade);
};
 
es.onerror = () => {
  // Browser automatically reconnects
  console.log("Reconnecting...");
};

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from typing import dict
 
app = FastAPI()
 
class ConnectionManager:
    def __init__(self):
        self.connections: dict[str, list[WebSocket]] = {}
    
    async def connect(self, room: str, ws: WebSocket):
        await ws.accept()
        self.connections.setdefault(room, []).append(ws)
    
    async def disconnect(self, room: str, ws: WebSocket):
        self.connections[room].remove(ws)
    
    async def broadcast(self, room: str, message: dict):
        for ws in self.connections.get(room, []):
            await ws.send_json(message)
 
manager = ConnectionManager()
 
@app.websocket("/ws/chat/{room}")
async def chat_ws(ws: WebSocket, room: str, user_id: str):
    await manager.connect(room, ws)
    try:
        while True:
            data = await ws.receive_json()
            # Broadcast to all clients in the room
            await manager.broadcast(room, {
                "user": user_id,
                "message": data["message"],
                "timestamp": datetime.utcnow().isoformat()
            })
    except WebSocketDisconnect:
        await manager.disconnect(room, ws)
        await manager.broadcast(room, {"user": user_id, "event": "left"})

// Client
const ws = new WebSocket("wss://api.example.com/ws/chat/room-123?user_id=alice");
 
ws.onopen = () => {
  ws.send(JSON.stringify({ message: "Hello!" }));
};
 
ws.onmessage = (event) => {
  const msg = JSON.parse(event.data);
  renderMessage(msg);
};
 
ws.onclose = () => {
  // Implement reconnect with exponential backoff
  setTimeout(reconnect, 1000);
};

import aioredis
 
redis = aioredis.from_url("redis://localhost")
 
@app.websocket("/ws/chat/{room}")
async def chat_ws(ws: WebSocket, room: str):
    await manager.connect(room, ws)
    
    # Subscribe to this room's Redis channel
    async with redis.pubsub() as pubsub:
        await pubsub.subscribe(f"room:{room}")
        
        async def receive_from_redis():
            async for message in pubsub.listen():
                if message["type"] == "message":
                    await ws.send_text(message["data"])
        
        async def receive_from_client():
            while True:
                data = await ws.receive_text()
                # Publish to Redis — all servers in the cluster receive it
                await redis.publish(f"room:{room}", data)
        
        await asyncio.gather(receive_from_redis(), receive_from_client())