You might not need websockets – Server Sent Events

When building real-time applications, WebSockets are often the first solution that comes to mind. They enable bidirectional, low-latency communication between the server and client, making them ideal for many real-time use cases.

However, not all real-time applications require bidirectional communication. Sometimes, you only need to push data from the server to the client, without expecting client responses. While WebSockets can handle unidirectional communication, they introduce additional complexity—especially as a project grows. Managing event types, standardizing payloads, and ensuring proper message handling can become tricky over time.

So, if bidirectional communication isn't necessary, why not use a simpler alternative? In this article, I'll show you how to achieve real-time, unidirectional data streaming from the server to the client using Server-Sent Events (SSE).

Server Sent Events

You might have heard the term SSE (server sent events), it started to become popular around 2020, when support became widely available across modern browsers

SSE provides a simple client API that listens for responses with the text/event-stream content type. This enables the server to push events directly to the client in a continuous stream—making it a lightweight alternative for real-time, unidirectional communication.

A simple server implementation using express

Setting up an SSE endpoint is simple and doesn’t require additional dependencies. Here’s a basic implementation that sends five messages, each one second apart:

1import express from "express";
2
3const app = express();
4
5app.get("/events", (_req, res) => {
6  res.setHeader("Content-Type", "text/event-stream");
7  res.setHeader("Cache-Control", "no-cache");
8  res.setHeader("Connection", "keep-alive");
9  res.setHeader("Access-Control-Allow-Origin", "*");
10
11  for (let i = 0; i < 5; i++) {
12    setTimeout(() => {
13      res.write(`data: ${JSON.stringify({ message: `Count = ${i}` })}\n\n`);
14    }, 1000 * i);
15  }
16});

Getting the events on the client

Handling SSE events on the client is just as simple. The built-in EventSource API makes it easy to listen for incoming messages.

The following snippet shows how to create a basic listener that logs incoming event data:

1const evtSource = new EventSource("http://localhost:3000/events");
2
3evtSource.onmessage = (event) => {
4  console.log(JSON.parse(event.data));
5};

You can see more information about this API here.

Limitations

One key limitation of Server-Sent Events (SSE) is that browsers enforce a limit on the number of open HTTP connections per domain.

Since SSE relies on maintaining an open HTTP connection for as long as events are being received, this restriction can lead to unexpected behavior if multiple connections are needed. Be mindful of this when designing your application to avoid potential issues.