On this article, we’ll discover learn how to use server-sent occasions to allow a consumer to obtain automated updates from a server through an HTTP connection. We’ll additionally take a look at why that is helpful, and we’ll present sensible demonstrations of learn how to use server-sent occasions with Node.js.

Desk of Contents

Why Server-sent Occasions Are Helpful

The Internet is predicated on request-response HTTP messages. Your browser makes a URL request and a server responds with information. Which will result in additional browser requests and server responses for photos, CSS, JavaScript and so on. The server can’t provoke messages to the browser, so how can it point out that information has modified? Fortuitously, you’ll be able to add options resembling dwell information bulletins, climate studies, and inventory costs with server-sent occasions.

Implementing dwell information updates utilizing customary net applied sciences has at all times been potential:

  • The Nineteen Nineties Internet used a full-page or body/iframe refresh.
  • The 2000s Internet launched Ajax, which might use lengthy polling to request information and replace the suitable DOM parts with new data.

Neither choice is right, because the browser should set off a refresh. If it makes requests too usually, no information may have modified so each the browser and server do pointless work. If it makes requests too slowly, it could miss an necessary replace and the inventory worth you’re watching has already crashed!

Server-sent events (SSE) enable a server to push information to the browser at any time:

  • The browser nonetheless makes the preliminary request to ascertain a connection.
  • The server returns an event-stream response and retains the connection open.
  • The server can use this connection to ship textual content messages at any level.
  • The incoming information raises a JavaScript occasion within the browser. An occasion handler perform can parse the information and replace the DOM.

In essence, SSE is an never-ending stream of information. Consider it as downloading an infinitely massive file in small chunks that you may intercept and browse.

SSE was first carried out in 2006 and all main browsers help the usual. It’s probably much less well-known than WebSockets, however server-sent occasions are less complicated, use customary HTTP, help one-way communication, and supply automated reconnection. This tutorial offers instance Node.js code with out third-party modules, however SSE is on the market in different server-side languages including PHP.

Server-sent Occasions Fast Begin

The next demonstration implements a Node.js net server which outputs a random quantity between 1 and 1,000 at a random interval of a minimum of as soon as each three seconds.

Beneath is our Node.js SSE demonstration (you’ll be able to open it in a separate browser tab when you desire).

The code makes use of the usual Node.js http and url modules for creating an internet server and parsing URLs:

import http from "node:http";
import url from "node:url";

The server examines the incoming URL request and reacts when it encounters a /random path:

const port = 8000;

http.createServer(async (req, res) => {

  const uri = url.parse(req.url).pathname;

  swap (uri) {
    case "/random":


console.log(`server working: http://localhost:${port}nn`);

It initially responds with the SSE HTTP event-stream header:

perform sseStart(res) {
  res.writeHead(200, {
    Content material-Kind: "textual content/event-stream",
    Cache-Management: "no-cache",
    Connection: "keep-alive"

One other perform then sends a random quantity and calls itself after a random interval has elapsed:

perform sseRandom(res) {
  res.write("information: " + (Math.ground(Math.random() * 1000) + 1) + "nn");
  setTimeout(() => sseRandom(res), Math.random() * 3000);

If you happen to run the code domestically, you’ll be able to check the response utilizing cURL in your terminal:

$> curl -H Settle for:textual content/event-stream http://localhost:8000/random
information: 481

information: 127

information: 975

Press Ctrl | Cmd and C to terminate the request.

The browser’s client-side JavaScript connects to the /random URI utilizing an EventSource object constructor:

const supply = new EventSource("/random");

Incoming information triggers a message occasion handler the place the string following information: is on the market within the occasion object’s .information property:

supply.addEventListener('message', e => {
  console.log('RECEIVED', e.information);

Necessary notes

  • Like Fetch(), the browser makes an ordinary HTTP request, so you might have to deal with CSP, CORS and optionally cross a second { withCredentials: true } argument to the EventSource constructor to ship cookies.
  • The server should retain particular person res response objects for each linked person to ship them information. It’s achieved within the code above by passing the worth in a closure to the following name.
  • Message information can solely be a string (maybe JSON) despatched within the format information: <message>nn. The terminating carriage returns are important.
  • The server can terminate an SSE response at any time with res.finish(), however…
  • When a disconnect happens, the browser routinely makes an attempt to reconnect; there’s no want to write down your personal reconnection code.

Superior Server-sent Occasions

SSE requires no extra code than that proven above, however the next sections focus on additional choices.

One vs many SSE channels

A server might present any variety of SSE channel URLs. For instance:

  • /newest/information
  • /newest/climate
  • /newest/stockprice

This can be sensible if a single web page reveals one matter, however much less so if a single web page reveals information, climate, and inventory costs. In that state of affairs, the server should keep three connections for every person, which might result in reminiscence issues as visitors will increase.

An alternate choice is to supply a single endpoint URL, resembling /newest, which sends any information sort on one communication channel. The browser might point out the matters of curiosity within the URL question string — for instance, /newest?sort=information,climate,stockprice — so the server can restrict SSE responses to particular messages.

Sending totally different information on a single channel

Messages from the server can have an related occasion: handed on the road above the information: to establish particular forms of data:

occasion: information
information: SSE is nice!

occasion: climate
information: { "temperature": "20C", "wind": "10Kph", "rain": "25%" }

occasion: inventory
information: { "image": "AC", "firm": "Acme Corp", "worth": 123.45, "improve": -1.1 }

These will not set off the client-side "message" occasion handler. It’s essential to add handlers for every sort of occasion. For instance:

supply.addEventListener('information', e => {

    .textContent = e.information;


supply.addEventListener('climate', e => {

  const w = JSON.parse(e.information);

    .textContent = `${ w.temperature } with ${ w.wind } wind`;


supply.addEventListener('inventory', e => {

  const s = JSON.parse(e.information);

  doc.getElementById(`stock-${ s.image }`)
    .textContent = `${ s.share }: ${ s.worth } (${ s.improve }%)`;


Utilizing information identifiers

Optionally, the server also can ship an id: after a information: line:

occasion: information
information: SSE is nice!
id: 42

If the connection drops, the browser sends the final id again to the server within the Final-Occasion-ID HTTP header so the server can resend any missed messages.

The newest ID can also be out there client-side within the occasion object’s .lastEventId property:

supply.addEventListener('information', e => {

  console.log(`final ID: ${ e.lastEventId }`);

    .textContent = e.information;


Specifying retry delays

Though reconnection is automated, your server could know that new information is just not anticipated for a particular interval, so there’s no have to retain an energetic communication channel. The server can ship a retry: response with a milliseconds worth both by itself or as a part of a last message. For instance:

retry: 60000
information: Please do not reconnect for one more minute!

On receipt, the browser will drop the SSE connection and try to reconnect after the delay interval has elapsed.

Different occasion handlers

In addition to "message" and named occasions, you may also create "open" and "error" handlers in your client-side JavaScript.

An "open" occasion triggers when the server connection is established. It could possibly be used to run further configuration code or initialize DOM parts:

const supply = new EventSource('/sse1');

supply.addEventListener('open', e => {

  console.log('SSE connection established.');


An "error" occasion triggers when the server connection fails or terminates. You may study the occasion object’s .eventPhase property to verify what occurred:

supply.addEventListener('error', e => {

    if (e.eventPhase === EventSource.CLOSED) {
      console.log('SSE connection closed');
    else {
      console.log('error', e);


Keep in mind, there’s no have to reconnect: it happens routinely.

Terminating SSE communication

The browser can terminate an SSE communication utilizing the EventSource object’s .shut() technique. For instance:

const supply = new EventSource('/sse1');

setTimeout(() => supply.shut(), 3_600_000);

The server can terminate the connection by:

  1. firing res.finish() or sending a retry: delay, then
  2. returning an HTTP standing 204 when the identical browser makes an attempt to reconnect.

Solely the browser can re-establish a connection by creating a brand new EventSource object.


Server Aspect Occasions present a option to implement dwell web page updates that are probably simpler, extra sensible, and extra light-weight than Fetch()-based Ajax polling. The complexity is on the server finish. It’s essential to:

  1. keep all person’s energetic connections in reminiscence, and
  2. set off information transmissions when one thing adjustments.

However that is totally underneath your management, and scaling must be no extra advanced than another net utility.

The one downside is that SSE doesn’t let you ship messages from the browser to the server (aside from the preliminary connection request). You might use Ajax, however that’s too sluggish for apps resembling motion video games. For correct two-way communication, you require WebSockets. We’ll have a brand new tutorial on that quickly!