WebSockets vs eventos enviados pelo servidor 2026: Web em tempo real explicada

Os recursos da web em tempo real exigemWebSocketsouEventos enviados pelo servidor (SSE). Ambos enviam dados do servidor para o cliente, mas funcionam de maneira diferente. Em 2026, o SSE ganhou popularidade para streaming de IA, enquanto os WebSockets continuam essenciais para a comunicação bidirecional. Este guia explica o código e ajuda você a escolher.

WebSockets: Full Duplex

WebSockets criam uma conexão TCP persistente. Tanto o cliente quanto o servidor podem enviar mensagens a qualquer momento — verdadeiro full-duplex. Usado para: aplicativos de bate-papo, ferramentas colaborativas, jogos ao vivo, plataformas de negociação.

# FastAPI WebSocket server
from fastapi import FastAPI, WebSocket

app = FastAPI()
connected = []

@app.websocket('/ws')
async def websocket_endpoint(ws: WebSocket):
    await ws.accept()
    connected.append(ws)
    try:
        while True:
            data = await ws.receive_text()
            # Broadcast to all clients
            for client in connected:
                await client.send_text(f'Message: {data}')
    except:
        connected.remove(ws)

// Browser WebSocket client
const ws = new WebSocket('wss://example.com/ws');

ws.onopen = () => console.log('Connected');
ws.onmessage = (e) => console.log('Received:', e.data);
ws.onerror  = (e) => console.error('Error:', e);
ws.onclose  = () => console.log('Disconnected');

// Send message
ws.send('Hello server!');

Eventos enviados pelo servidor (SSE): Push unidirecional

SSE usa uma conexão HTTP regular onde o servidor transmite eventos. O cliente não pode enviar dados de volta (use solicitações HTTP separadas para isso). Reconecta automaticamente ao desconectar. Funciona em multiplexação HTTP/2. Usado para: feeds ao vivo, streaming de resposta de IA, notificações, barras de progresso.

# FastAPI SSE server
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio

app = FastAPI()

@app.get('/stream')
async def stream():
    async def event_generator():
        for i in range(10):
            yield f'data: Message {i}\n\n'
            await asyncio.sleep(1)
    return StreamingResponse(
        event_generator(),
        media_type='text/event-stream'
    )

// Browser SSE client
const evtSource = new EventSource('/stream');

evtSource.onmessage = (e) => {
  console.log('Received:', e.data);
};

evtSource.onerror = (e) => {
  console.error('Error:', e);
  // EventSource auto-reconnects after error
};

// Close when done
evtSource.close();

Streaming de IA com SSE (padrão 2026)

APIs LLM (Claude, OpenAI) transmitem respostas via SSE. Aqui está o padrão para encaminhar o streaming de Claude para o navegador.

import anthropic
from fastapi.responses import StreamingResponse

client = anthropic.Anthropic()

@app.post('/ask')
async def ask(question: str):
    async def generate():
        with client.messages.stream(
            model='claude-sonnet-4-5',
            max_tokens=1024,
            messages=[{'role': 'user', 'content': question}]
        ) as stream:
            for text in stream.text_stream:
                yield f'data: {text}\n\n'
        yield 'data: [DONE]\n\n'

    return StreamingResponse(generate(), media_type='text/event-stream')

Comparação

• WebSockets:TCP bidirecional, persistente, binário ou texto, reconexão manual
• SSE:Somente servidor para cliente, HTTP, somente texto, reconexão automática, mais simples
• Sobrecarga de WebSockets:Configuração mais pesada (handshake de atualização, gerenciamento de estado)
• Sobrecarga de SSE:Mínimo — funciona com qualquer servidor HTTP, compatível com CDN

Quando usar qual

• WebSockets:Bate-papo, jogos multijogador, edição colaborativa (estilo Google Docs)
• SSE:Streaming de resposta de IA, feeds ao vivo, notificações, atualizações de progresso
• Nenhum dos dois:A pesquisa a cada 30 anos ou mais é mais simples e muitas vezes suficiente para atualizações de baixa frequência

Conclusão

Em 2026, o SSE é a escolha certa para a maioria dos recursos em tempo real – mais simples, funciona em HTTP/2, compatível com CDN e perfeito para streaming de IA. Escolha WebSockets apenas quando precisar de uma comunicação bidirecional verdadeira. Comece com SSE e atualize para WebSockets se atingir seus limites.