Socket.IO — what it is, a library for real-time interaction

What is Socket.IO?

Socket.IO is an open-source JavaScript library for bidirectional event-driven communication between client and server. It was created in 2010 by developer Guillermo Rauch and has since become the de facto standard for real-time applications on Node.js.

Unlike the native WebSocket API, Socket.IO provides additional abstractions: rooms, namespaces, automatic reconnection, and binary data types. The library is not a separate implementation of WebSocket — it uses Engine.IO as a transport layer, which first establishes an HTTP long-polling connection, then attempts to upgrade to WebSocket.

According to npm statistics (2025), more than 12 million copies of the socket.io package are downloaded weekly, making it one of the most popular libraries in the Node.js ecosystem. Socket.IO is supported on all modern platforms: browsers, iOS, Android, React Native, and desktop applications.

History and Versions

Socket.IO version 1.0 was released in 2014 and introduced the concept of namespaces, which allow multiplexing multiple logical channels over a single TCP connection. Version 2.0 (2017) added support for binary data and improved parsing performance. The current version 4.x (2020–2025) includes full TypeScript support, a flagship adapter mode for scaling, and improved backward compatibility.

Each major release maintains API backward compatibility — a socket.io@2 client can connect to a socket.io@4 server through a special compatibility mode. This is important for long-lived projects where client-side upgrades happen gradually.

How Socket.IO Works

Socket.IO architecture consists of two components: the server module (npm package socket.io) and the client module (npm package socket.io-client). The server runs on top of a Node.js HTTP(S) server and uses Engine.IO to manage the transport layer.

On initial connection, the client sends an HTTP request to the server. Engine.IO responds and establishes a long-polling connection. After that, the client sends a request to upgrade the transport protocol to WebSocket. If the server supports WebSocket, the upgrade happens within a single TCP session. If not, the connection remains on long-polling, and the application code requires no changes.

According to Socket.IO performance tests (2024), when using WebSocket, latency is 2–5 ms per message transmission, while long-polling adds 150–300 ms due to HTTP overhead. The transport choice is transparent to the developer.

Engine.IO Protocol

Engine.IO is the low-level transport layer on which Socket.IO is built. It handles connection establishment, transport selection, heartbeat (ping/pong), and connection termination. The main Engine.IO packet types are: open (initialization), close (termination), ping/pong (keep-alive), upgrade (transport change), and message (data).

Socket.IO builds its event-driven model on top of Engine.IO — this is what the developer works with. Each Socket.IO message is wrapped in an Engine.IO packet of type message with a unique identifier for delivery confirmation.

Key Features of Socket.IO

Socket.IO provides a set of features that are absent in the native WebSocket API and make developing real-time applications significantly easier. Let's look at the main ones.

Automatic reconnection — the client automatically restores the connection on disconnect with exponential backoff (100 ms, 200 ms, 400 ms... up to a maximum). According to the Socket.IO documentation (2024), retry settings are available through the reconnectionDelay and reconnectionAttempts parameters. This option is critical for mobile applications where connections may be interrupted during network changes.

Room support — the server can group sockets into rooms and send messages only to participants of a specific room. Rooms do not require explicit creation — they are created when the first socket joins. Rooms are implemented at the process level and are not shared between different servers without a special adapter.

Namespaces — logical separation of communication channels on a single connection. For example, the /chat namespace for chat messages and /notifications for notifications. Each namespace has its own rooms, middleware, and handlers. Namespaces are multiplexed over a single TCP connection, saving resources.

Delivery acknowledgment — when sending a message, you can pass a callback function that will be called when the server confirms receipt. This is implemented through a unique identifier for each packet. The acknowledgment mechanism ensures that critically important messages (e.g., payment transactions) are delivered to the recipient.

Socket.IO vs WebSocket: Comparison

The choice between Socket.IO and native WebSocket depends on project requirements. WebSocket is a standardized protocol (RFC 6455) supported by all modern browsers. Socket.IO is a library that uses WebSocket as transport but adds additional features.

If your project requires maximum performance and minimal client size — choose native WebSocket. If you need reliable delivery, grouping, and an event-driven model — Socket.IO will reduce development time by 2–3 times thanks to ready-made abstractions.

According to the State of JS 2024 survey, 67% of real-time application developers prefer Socket.IO due to its convenient API and built-in handling of edge cases (network disconnection, reconnection, binary data).

How to Connect Socket.IO in a Project

Installing Socket.IO requires two packages: server-side and client-side. Let's look at the basic setup for a Node.js project. The server creates an HTTP server, initializes Socket.IO, and handles client connection and disconnection events.

According to the Socket.IO documentation (2024), the server can be started without Express using the built-in http module, but real projects typically use Express or Fastify for HTTP request routing.

Server-side Code in Node.js

const express = require('express');
const http = require('http');
const Server = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = new Server(server, {
    cors: { origin: '*' }
});

io.on('connection', (socket) => {
    console.log('Client connected:', socket.id);

    socket.emit('welcome', { message: 'Hello from server' });

    socket.on('disconnect', () => {
        console.log('Client disconnected');
    });
});

server.listen(3000, () => {
    console.log('Server running on port 3000');
});

Client-side Code in Browser

import { io } from 'socket.io-client';

const socket = io('http://localhost:3000', {
    transports: ['websocket', 'polling'],
    reconnectionDelay: 1000
});

socket.on('welcome', (data) => {
    console.log(data.message);
});

socket.emit('chat message', {
    user: 'Alice',
    text: 'Hello everyone!'
});

Events and Rooms in Socket.IO

Socket.IO event model is based on named events. The server and client send and receive messages bound to a specific event name. The payload can be a string, JSON object, or binary data (Buffer, ArrayBuffer, Blob).

Each event supports ACK (acknowledgement) — passing a callback function that executes on the sender's side after the event is processed by the receiver. This allows implementing a request-response pattern on top of the event model. ACK only works if the receiver explicitly calls the callback.

According to the Socket.IO documentation (2024), the maximum size of a single message should not exceed 1 MB for optimal performance. Larger messages should be split into fragments or sent through a separate channel.

Working with Rooms

io.on('connection', (socket) => {
    socket.join('room-1');

    socket.to('room-1').emit('user joined', {
        userId: socket.id
    });

    io.to('room-1').emit('message', {
        text: 'Broadcast to room'
    });

    socket.leave('room-1');
});

Scaling Socket.IO

Horizontal scaling of Socket.IO requires solving the problem of state sharing between multiple server processes. Rooms, namespaces, and the list of connected sockets are stored in the memory of a single process and are not visible to other processes without an adapter.

Official Socket.IO adapters: redis (via Redis Pub/Sub), mongodb (via MongoDB change streams), cluster (for Node.js cluster multiprocess mode). The adapter acts as a message broker between Socket.IO instances. When an event is sent to a room, the adapter publishes it to Redis, and all servers receive the notification.

According to Socket.IO load testing (2024), a cluster of 4 servers with the Redis adapter handles up to 400,000 concurrent connections with latency under 10 ms. Without an adapter, the maximum capacity of a single Node.js process is around 100,000 connections with 1 GB of memory.

Redis Adapter Configuration

const Server = require('socket.io');
const RedisAdapter = require('@socket.io/redis-adapter');
const Redis = require('ioredis');

const pubClient = new Redis({ host: 'localhost', port: 6379 });
const subClient = pubClient.duplicate();
const io = new Server(server);
io.adapter(RedisAdapter(pubClient, subClient));

When using Kubernetes or Docker Swarm, it is recommended to additionally configure session affinity (sticky sessions) so that requests from the same client go to the same server; otherwise, the assignment may change with each reconnection.