Web DevelopmentOpinion & Analysis

WebSocket vs Server-Sent Events vs Long Polling

Choose the right real-time communication strategy. A technical comparison of WebSockets, SSE, and long polling with decision criteria.

Mbeah Essilfie

May 16, 2026 at 06:04 AM

8 min read 491 views

WebSocket vs Server-Sent Events vs Long Polling

The Real-Time Spectrum

Not all "real-time" needs are equal. Choose based on your actual requirements, not on what sounds coolest.

Long Polling

The simplest approach — client asks "anything new?" repeatedly:

// Client
async function poll() {
  while (true) {
    try {
      const response = await fetch('/api/updates?since=' + lastTimestamp)
      const data = await response.json()
      if (data.updates.length > 0) {
        handleUpdates(data.updates)
        lastTimestamp = data.timestamp
      }
    } catch (e) {
      await sleep(5000) // backoff on error
    }
    await sleep(1000) // poll interval
  }
}

Pros: Works everywhere, simple to implement, stateless server Cons: Latency (up to poll interval), wasted requests, server load

Use when: Simple notification checks, legacy browser support needed

Server-Sent Events (SSE)

Server pushes to client over a persistent HTTP connection:

// Server (Nuxt/Nitro)
export default defineEventHandler((event) => {
  setHeader(event, 'Content-Type', 'text/event-stream')
  setHeader(event, 'Cache-Control', 'no-cache')

  const stream = new ReadableStream({
    start(controller) {
      const send = (data: unknown) => {
        controller.enqueue(`data: ${JSON.stringify(data)}\n\n`)
      }

      // Subscribe to updates
      const unsubscribe = subscribe('updates', send)
      event.node.req.on('close', () => {
        unsubscribe()
        controller.close()
      })
    },
  })

  return sendStream(event, stream)
})

// Client
const source = new EventSource('/api/stream')
source.onmessage = (event) => {
  const data = JSON.parse(event.data)
  handleUpdate(data)
}
source.onerror = () => {
  // EventSource auto-reconnects!
}

Pros: Auto-reconnection, simple API, works through most proxies, HTTP/2 multiplexing Cons: Unidirectional (server → client only), text-only, limited connections per domain

Use when: Live feeds, notifications, dashboards, stock tickers

SSE is my default recommendation for most real-time features. It's simpler than WebSockets, auto-reconnects, and is sufficient for 80% of use cases.

WebSockets

Full-duplex communication channel:

// Server
const wss = new WebSocketServer({ port: 8080 })

wss.on('connection', (ws) => {
  ws.on('message', (data) => {
    const message = JSON.parse(data.toString())
    // Handle client messages
    if (message.type === 'subscribe') {
      channels.add(ws, message.channel)
    }
  })

  // Push to client
  ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }))
})

Pros: Bidirectional, binary data support, lowest latency, established standard Cons: Stateful (scaling is harder), no auto-reconnect, blocked by some proxies

Use when: Chat, multiplayer games, collaborative editing, bidirectional streaming

Comparison Table

Feature	Long Polling	SSE	WebSocket
Direction	Client → Server	Server → Client	Bidirectional
Auto-reconnect	Manual	Built-in	Manual
Binary data	❌	❌	✅
HTTP/2 compatible	✅	✅	❌
Proxy-friendly	✅	✅	⚠️
Scaling difficulty	Low	Medium	High
Browser support	All	All modern	All modern