Socket.IO Comparison

# Server
npm install socket.io

# Client (browser build also available via CDN)
npm install socket.io-client

import { createServer } from "http";
import { Server } from "socket.io";
import express from "express";

const app = express();
const httpServer = createServer(app);
const io = new Server(httpServer, {
  cors: { origin: "https://example.com", methods: ["GET", "POST"] },
});

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

  socket.on("chat", (data) => {
    io.to("general").emit("chat", data); // broadcast to room
  });

  socket.on("disconnect", (reason) => {
    console.log("disconnected:", reason);
  });
});

httpServer.listen(4000);

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

const socket = io("https://api.example.com", {
  path: "/socket.io",          // default
  transports: ["websocket"],   // skip polling entirely
  auth: { token: jwt },        // server reads socket.handshake.auth.token
  reconnectionDelayMax: 30_000,
  autoConnect: true,
});

socket.on("connect",    () => console.log("id:", socket.id));
socket.on("disconnect", (reason) => console.log("reason:", reason));
socket.on("chat",       (data)   => console.log("msg:", data));

socket.emit("chat", { text: "Hello", room: "general" });

// Server side
socket.emit("event", payload);                 // to this socket only
socket.to(roomId).emit("event", payload);      // to room, exclude sender
io.to(roomId).emit("event", payload);          // to room, include sender
io.emit("event", payload);                     // broadcast to all
socket.broadcast.emit("event", payload);       // all except this socket
io.to(roomId).except(socket.id).emit(...);     // to room, except sender (v4)
io.to([roomA, roomB]).emit("event", payload);  // multiple rooms at once

// Client side
socket.emit("event", payload);
socket.emit("event", payload, callback);       // with ack

// Client emits with ack callback
socket.emit("save", { text: "note" }, (response) => {
  console.log("server ack:", response); // { ok: true, id: 42 }
});

// Server replies via ack function
io.on("connection", (socket) => {
  socket.on("save", (data, ack) => {
    const id = saveToDb(data);
    ack({ ok: true, id }); // call ack to reply
  });
});

// Server emits with ack (v4.6+)
const response = await io.to(socketId).emitWithAck("ping");
// Client: socket.on("ping", (ack) => ack("pong"));

// Server — join / leave
socket.join("room-42");        // join
socket.leave("room-42");       // leave
socket.rooms;                  // Set — rooms this socket is in (always includes socket.id)

// Auto room: socket.id is a single-socket room (for private messages)
io.to(socket.id).emit("private", { text: "only you" });

// Broadcast to room
io.to("room-42").emit("update", data);
socket.to("room-42").emit("update", data);  // exclude sender

// Leave all rooms (socket does this automatically on disconnect)
for (const room of socket.rooms) socket.leave(room);

// Server
const chatNs  = io.of("/chat");
const adminNs = io.of("/admin");

chatNs.on("connection", (socket) => {
  socket.emit("welcome", "chat namespace");
});

adminNs.use((socket, next) => {
  if (isAdmin(socket.handshake.auth.token)) next();
  else next(new Error("Unauthorized"));
});

// Client
const chatSocket  = io("https://api.example.com/chat");
const adminSocket = io("https://api.example.com/admin", { auth: { token } });

// Global middleware — runs for every socket before connection event
io.use((socket, next) => {
  const token = socket.handshake.auth.token;
  try {
    socket.user = jwt.verify(token, SECRET);
    next();
  } catch {
    next(new Error("Authentication error"));
  }
});

// Namespace middleware
io.of("/admin").use((socket, next) => {
  if (!socket.user?.isAdmin) return next(new Error("Forbidden"));
  next();
});

npm install @socket.io/redis-adapter redis

import { createAdapter } from "@socket.io/redis-adapter";
import { createClient } from "redis"; // node-redis

const pub = createClient({ url: process.env.REDIS_URL });
const sub = pub.duplicate();
await Promise.all([pub.connect(), sub.connect()]);

io.adapter(createAdapter(pub, sub));
// Now io.to("room").emit(...) works across all server instances

import { createAdapter } from "@socket.io/redis-adapter";
import Redis from "ioredis";

const pub = new Redis(process.env.REDIS_URL);
const sub = pub.duplicate();
io.adapter(createAdapter(pub, sub));