Server-Sent Events vs WebSocket: quando uma via basta

Conheça o Server-Sent Events (SSE), a alternativa simples ao WebSocket para streaming do servidor pro cliente, com exemplo em Node, reconexão automática e o uso em respostas de IA token a token.

tecnico backend api 4 min de leitura

Quando o assunto é tempo real, quase todo mundo pensa em WebSocket. Mas boa parte dos casos (notificações, progresso de uma tarefa, a resposta de uma IA aparecendo palavra por palavra) só precisa de dados indo numa direção: do servidor pro cliente. Pra isso existe uma ferramenta mais simples, e que muita gente desconhece.

O que é Server-Sent Events

SSE é um recurso do HTTP em que o cliente abre uma requisição normal e o servidor mantém a conexão aberta, enviando eventos de texto sempre que tem algo novo. Não há protocolo novo, é HTTP comum com uma resposta que não termina.

A comunicação é de uma via: o servidor fala, o cliente escuta. Se o cliente precisa enviar algo, usa uma requisição POST normal em paralelo.

No navegador: a API EventSource

O navegador já traz tudo pronto, sem biblioteca:

const fonte = new EventSource("/api/notificacoes");
 
fonte.onmessage = (evento) => {
  const dados = JSON.parse(evento.data);
  console.log("Nova notificação:", dados);
};
 
fonte.onerror = () => {
  console.log("Conexão perdida, tentando reconectar...");
};

No servidor: o formato

A resposta usa o tipo text/event-stream, e cada evento é um bloco de texto terminado por uma linha em branco. Um exemplo em Node com Express:

app.get("/api/notificacoes", (req, res) => {
  res.setHeader("Content-Type", "text/event-stream");
  res.setHeader("Cache-Control", "no-cache");
  res.setHeader("Connection", "keep-alive");
  res.flushHeaders();
 
  const enviar = (dados) => {
    res.write(`data: ${JSON.stringify(dados)}\n\n`);
  };
 
  const intervalo = setInterval(() => {
    enviar({ hora: new Date().toISOString() });
  }, 2000);
 
  req.on("close", () => {
    clearInterval(intervalo);
  });
});

Dois pontos importantes: o \n\n no final marca o fim de cada evento, e o req.on("close") limpa os recursos quando o cliente fecha a página. Sem isso, cada conexão abandonada deixa um intervalo rodando no servidor.

Também dá pra nomear eventos e atribuir IDs:

event: pedido-atualizado
id: 42
data: {"status": "enviado"}

No cliente, fonte.addEventListener("pedido-atualizado", ...) escuta só esse tipo.

O que o SSE entrega de graça

  • Reconexão automática. Se a conexão cair, o navegador reconecta sozinho.
  • Retomada. Com o cabeçalho Last-Event-ID, o servidor sabe o último evento recebido e pode reenviar o que foi perdido.
  • Funciona sobre HTTP. Passa por proxies, autenticação por cookie e HTTP/2 sem configuração especial.

Com o WebSocket, tudo isso é trabalho seu: reconexão, retomada e autenticação precisam ser implementados à mão, como apareceu no post sobre WebSocket.

O caso de uso do momento: respostas de IA

Quando uma IA responde palavra por palavra no chat, o que está acontecendo por baixo costuma ser exatamente SSE. O servidor da API do modelo envia pedaços do texto conforme são gerados, e a interface vai montando a resposta:

const resposta = await fetch("/api/chat", {
  method: "POST",
  body: JSON.stringify({ pergunta }),
});
 
const leitor = resposta.body.getReader();
const decodificador = new TextDecoder();
 
while (true) {
  const { done, value } = await leitor.read();
  if (done) break;
  console.log(decodificador.decode(value)); // pedaço do texto
}

Nesse caso é comum usar fetch com leitura do stream em vez de EventSource, porque o EventSource só faz requisições GET, e aqui você precisa enviar a pergunta num POST.

Limitações

  • Só texto. Dados binários precisam ser codificados (base64, por exemplo).
  • Só uma direção. Pro caminho inverso, requisições comuns.
  • Limite de conexões no HTTP/1.1. O navegador limita cerca de seis conexões por domínio, e cada aba com SSE ocupa uma. Em HTTP/2 isso deixa de ser problema, porque as conexões são multiplexadas.
  • Servidores serverless. Funções com tempo limite de execução cortam a conexão. Pra SSE de longa duração, você precisa de um servidor que fique ativo.

Quando usar cada um

SSE quando o fluxo é do servidor pro cliente: notificações, feeds, dashboards ao vivo, progresso de upload ou processamento, streaming de IA.

WebSocket quando os dois lados conversam o tempo todo e com baixa latência: chat entre pessoas, jogos multiplayer, edição colaborativa, cursores compartilhados.

Polling (perguntar de tempos em tempos) quando a atualização é rara e não precisa ser instantânea. Continua sendo a opção mais simples de todas.

Fechando

WebSocket é poderoso, mas a maioria dos recursos de tempo real não precisa de comunicação nos dois sentidos. SSE entrega o que importa, com menos código, reconexão automática e compatibilidade com a infraestrutura HTTP que você já tem. Antes de subir um servidor WebSocket, vale perguntar: o cliente realmente precisa falar de volta pelo mesmo canal?

Direto na sua
caixa de entrada.

Um aviso por e-mail sempre que eu publicar um post novo. Sem spam, sem newsletter chata, só isso.