WebSocket vs SSE vs Long Polling: Choosing Real-time in 2025

# ❌ Polling every 2 seconds from frontend
@app.get("/messages")
async def get_messages(last_id: int = 0):
    return await db.query(
        "SELECT * FROM messages WHERE id > ?", last_id
    )

# Client
ws = new WebSocket('ws://localhost:8000/ws')
ws.send('Hello')              // Client → Server
ws.onmessage = (msg) => {...} // Server → Client
 
# Server (FastAPI)
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    await websocket.send_text("Welcome!")  # Server → Client
    data = await websocket.receive_text()  # Client → Server

# Client
const eventSource = new EventSource('/sse')
eventSource.onmessage = (event) => {
  console.log(event.data) // Only receiving
}
 
# Server (FastAPI)
@app.get("/sse")
async def sse_endpoint(request: Request):
    async def event_stream():
        while True:
            yield f"data: {datetime.now()}\n\n"
            await asyncio.sleep(1)
 
    return StreamingResponse(
        event_stream(),
        media_type="text/event-stream"
    )

# Client
async function poll() {
  const response = await fetch('/poll?last_id=123')
  const data = await response.json()
  processData(data)
  poll() // Immediately next request
}
 
# Server (FastAPI)
@app.get("/poll")
async def long_poll(last_id: int = 0):
    # Wait up to 30 seconds for new data
    for _ in range(30):
        new_data = await get_new_messages(last_id)
        if new_data:
            return new_data
        await asyncio.sleep(1)
 
    return []  # Timeout, client will retry

location /ws {
    proxy_pass http://backend;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
 
    # Increased to 1 hour
    proxy_read_timeout 3600s;
    proxy_send_timeout 3600s;
}

# Server sends ping every 30 seconds
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
 
    async def send_ping():
        while True:
            try:
                await websocket.send_text("ping")
                await asyncio.sleep(30)
            except:
                break
 
    asyncio.create_task(send_ping())
 
    # ... message processing

ws.onmessage = (event) => {
  if (event.data === "ping") {
    ws.send("pong"); // Reply to heartbeat
    return;
  }
  // process real messages
};

location /sse {
    proxy_pass http://backend;
 
    # Disable buffering for SSE
    proxy_buffering off;
    proxy_cache off;
 
    # Required for SSE
    proxy_set_header Connection '';
    proxy_http_version 1.1;
    chunked_transfer_encoding off;
 
    # HTTP/1.1 keep-alive
    proxy_read_timeout 86400s;
}

from starlette.responses import StreamingResponse
 
@app.get("/sse")
async def sse(request: Request):
    async def event_generator():
        while True:
            if await request.is_disconnected():
                break
 
            # SSE format: "data: <payload>\n\n"
            yield f"data: {json.dumps({'time': time.time()})}\n\n"
            await asyncio.sleep(1)
 
    return StreamingResponse(
        event_generator(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # For Nginx
        }
    )

# ❌ Bad: Sync workers
gunicorn app:app --workers 4 --worker-class sync
 
# ✅ Good: Async workers (gevent or uvicorn)
gunicorn app:app --workers 4 --worker-class uvicorn.workers.UvicornWorker

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from typing import List
import json
 
app = FastAPI()
 
# Connection manager
class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []
 
    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)
 
    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)
 
    async def broadcast(self, message: str):
        """Send to all clients"""
        for connection in self.active_connections:
            try:
                await connection.send_text(message)
            except:
                # If send failed — remove connection
                self.disconnect(connection)
 
manager = ConnectionManager()
 
@app.websocket("/ws/chat")
async def websocket_chat(websocket: WebSocket):
    await manager.connect(websocket)
 
    try:
        while True:
            # Receive message from client
            data = await websocket.receive_text()
 
            message = json.loads(data)
            username = message.get("username", "Anonymous")
            text = message.get("text", "")
 
            # Broadcast to all
            await manager.broadcast(json.dumps({
                "username": username,
                "text": text,
                "timestamp": time.time()
            }))
 
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        await manager.broadcast(json.dumps({
            "system": f"User left the chat"
        }))

const ws = new WebSocket("ws://localhost:8000/ws/chat");
 
ws.onopen = () => console.log("Connected");
 
ws.onmessage = (event) => {
  const message = JSON.parse(event.data);
  addMessageToUI(message);
};
 
// Send message
function sendMessage(text) {
  ws.send(
    JSON.stringify({
      username: "User123",
      text: text,
    })
  );
}
 
// Reconnect on disconnect
ws.onclose = () => {
  console.log("Disconnected, reconnecting...");
  setTimeout(() => location.reload(), 1000);
};

from fastapi import FastAPI, Request
from sse_starlette.sse import EventSourceResponse
import asyncio
import psutil
import json
 
app = FastAPI()
 
async def generate_metrics():
    """Generate metrics every second"""
    while True:
        metrics = {
            "cpu_percent": psutil.cpu_percent(interval=1),
            "memory_percent": psutil.virtual_memory().percent,
            "timestamp": time.time()
        }
 
        # SSE format
        yield {
            "event": "metrics",
            "data": json.dumps(metrics)
        }
 
        await asyncio.sleep(1)
 
@app.get("/sse/metrics")
async def sse_metrics(request: Request):
    """SSE endpoint for metrics"""
 
    async def event_stream():
        try:
            async for event in generate_metrics():
                # Check if client is alive
                if await request.is_disconnected():
                    break
 
                # SSE format: event: <type>\ndata: <payload>\n\n
                yield f"event: {event['event']}\n"
                yield f"data: {event['data']}\n\n"
 
        except asyncio.CancelledError:
            # Client disconnected
            pass
 
    return EventSourceResponse(
        event_stream(),
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",
        }
    )

const eventSource = new EventSource("/sse/metrics");
 
eventSource.addEventListener("metrics", (event) => {
  const data = JSON.parse(event.data);
 
  updateChart("cpu", data.cpu_percent);
  updateChart("memory", data.memory_percent);
});
 
eventSource.onerror = () => {
  console.error("SSE connection failed");
  eventSource.close();
 
  // Reconnect in 5 seconds
  setTimeout(() => location.reload(), 5000);
};

// Receive metrics via SSE
const eventSource = new EventSource("/sse/metrics");
 
// Send commands via fetch
async function restartService() {
  await fetch("/api/restart", { method: "POST" });
}

from fastapi import FastAPI
import asyncio
 
app = FastAPI()
 
# In-memory notification queue (in prod — Redis/DB)
notifications_queue = []
 
@app.get("/poll/notifications")
async def poll_notifications(last_id: int = 0):
    """
    Long polling: wait up to 30 seconds for new notifications
    """
    timeout_seconds = 30
 
    for _ in range(timeout_seconds):
        # Check for new notifications
        new_notifications = [
            n for n in notifications_queue
            if n["id"] > last_id
        ]
 
        if new_notifications:
            return {"notifications": new_notifications}
 
        # Wait 1 second before next check
        await asyncio.sleep(1)
 
    # Timeout — return empty response
    return {"notifications": []}
 
@app.post("/notifications")
async def create_notification(text: str):
    """Create notification (for testing)"""
    notification = {
        "id": len(notifications_queue) + 1,
        "text": text,
        "timestamp": time.time()
    }
    notifications_queue.append(notification)
    return notification

let lastNotificationId = 0;
 
async function pollNotifications() {
  try {
    const response = await fetch(
      `/poll/notifications?last_id=${lastNotificationId}`
    );
    const data = await response.json();
 
    if (data.notifications.length > 0) {
      data.notifications.forEach(showNotification);
      lastNotificationId = Math.max(...data.notifications.map((n) => n.id));
    }
  } catch (error) {
    console.error("Polling failed:", error);
    // Backoff on error
    await new Promise((resolve) => setTimeout(resolve, 5000));
  }
 
  // Immediately next request
  pollNotifications();
}
 
// Start
pollNotifications();

import aioredis
 
redis = aioredis.from_url("redis://localhost")
 
@app.get("/poll/notifications")
async def poll_notifications(user_id: int, last_id: int = 0):
    """Long polling via Redis Pub/Sub"""
 
    # Subscribe to user channel
    pubsub = redis.pubsub()
    await pubsub.subscribe(f"user:{user_id}:notifications")
 
    # Wait for event or timeout
    try:
        async with asyncio.timeout(30):
            async for message in pubsub.listen():
                if message["type"] == "message":
                    notification = json.loads(message["data"])
                    return {"notifications": [notification]}
 
    except asyncio.TimeoutError:
        return {"notifications": []}
 
    finally:
        await pubsub.unsubscribe()
 
# On notification creation — publish to Redis
@app.post("/notifications")
async def create_notification(user_id: int, text: str):
    notification = {"id": generate_id(), "text": text}
 
    # Publish to user channel
    await redis.publish(
        f"user:{user_id}:notifications",
        json.dumps(notification)
    )
 
    return notification

from fastapi import FastAPI
 
app = FastAPI()
 
# WebSocket for support chat
@app.websocket("/ws/support")
async def support_chat(websocket: WebSocket):
    # Bidirectional chat with operators
    ...
 
# SSE for real-time metrics
@app.get("/sse/metrics")
async def metrics_stream(request: Request):
    # Chart updates every 5 seconds
    ...
 
# Long Polling for rare notifications
@app.get("/poll/notifications")
async def poll_notifications(last_id: int):
    # Task completion notifications
    ...
 
# Regular REST for everything else
@app.get("/api/users")
async def get_users():
    ...

from prometheus_client import Counter, Histogram
 
ws_connections = Counter('ws_connections_total', 'WebSocket connections')
ws_messages = Counter('ws_messages_total', 'WebSocket messages sent')
ws_latency = Histogram('ws_message_latency_seconds', 'Message latency')
 
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    ws_connections.inc()
 
    start = time.time()
    await websocket.send_text("hello")
    ws_latency.observe(time.time() - start)
 
    ws_messages.inc()

import logging
 
logger = logging.getLogger(__name__)
 
@app.get("/sse")
async def sse(request: Request):
    client_id = request.client.host
    logger.info(f"SSE connected: {client_id}")
 
    async def event_stream():
        try:
            while True:
                yield f"data: {time.time()}\n\n"
                await asyncio.sleep(1)
        except Exception as e:
            logger.error(f"SSE error for {client_id}: {e}")
        finally:
            logger.info(f"SSE disconnected: {client_id}")
 
    return StreamingResponse(event_stream(), media_type="text/event-stream")