Unlocking Real-time Communication: A Guide to WebSockets and Socket.IO for Fullstack Developers

As web applications continue to evolve, the need for real-time communication between the server and the client becomes increasingly important. Whether it's a chat application or a stock trading platform, users expect instant updates and interactions. In this tutorial, we'll learn about WebSockets and Socket.IO and how they enable developers to implement real-time communication in their web applications. We'll explore practical examples and tips for fullstack developers looking to create highly interactive, data-driven applications.

What are WebSockets?

WebSockets are a protocol that enables two-way communication between a web browser and a server. Unlike traditional HTTP requests, which are unidirectional, WebSockets allow the server to push data to the client without the client first requesting it. This capability enables real-time, event-driven communication between the server and the client.

WebSockets were introduced as a part of HTML5 specification and are supported by all modern web browsers. The WebSocket protocol is defined by IETF as RFC 6455. Below is an example of how a WebSocket connection is established:

// create WebSocket instance
const ws = new WebSocket('wss://example.com/socket');

// WebSocket event listeners
ws.onopen = () => {
  console.log('WebSocket connection established');

ws.onmessage = (event) => {
  console.log(`Received message: ${event.data}`);

ws.onclose = () => {
  console.log('WebSocket connection closed');

In the example above, we create a WebSocket instance and connect to the server using the URL wss://example.com/socket. We then define three event listeners: onopen which is triggered when the connection is established, onmessage which is triggered when a message is received from the server, and onclose which is triggered when the connection is closed.

What is Socket.IO?

Socket.IO is a library built on top of WebSockets that simplifies real-time communication between the server and the client. Socket.IO provides two-way communication channels between the server and each connected client, enabling real-time updates and interactions.

Socket.IO also provides fallback options, like XHR-polling and JSONP-polling, for older browsers that don't support WebSockets. Additionally, Socket.IO enables developers to create rooms, namespaces, and broadcast messages to specific groups of clients.

Implementing Real-time Communication using Socket.IO

Let's take a look at a practical example of using Socket.IO for a real-time chat application. We'll use Node.js for our server-side code and Angular for our client-side code.

Server-side Code

First, let's install the Socket.IO library in our Node.js project:

npm install socket.io

Next, we'll create our server-side code using Node.js and Socket.IO. Here's a simple example:

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

// Socket.IO event listeners
io.on('connection', (socket) => {
  console.log('A user connected');

  // listen for message event
  socket.on('message', (data) => {
    console.log(`Received message: ${data}`);
    io.emit('message', data);

  // listen for disconnect event
  socket.on('disconnect', () => {
    console.log('A user disconnected');

// start server
http.listen(3000, () => {
  console.log('Server started on http://localhost:3000');

In the code above, we create an HTTP server and a Socket.IO instance using Express.js and Node.js. We then define event listeners for when a client connects, disconnects, and sends a message. When a message is received, we log the message to the console and emit the message to all connected clients using io.emit() method.

Client-side Code

For our client-side code, we'll use Angular. We'll create a simple chat application with a form for users to enter their name and message:

<!-- index.html -->
<form #chatForm (ngSubmit)="sendMessage(chatForm.value)">
  <input type="text" name="name" [(ngModel)]="name" placeholder="Your name" required>
  <input type="text" name="message" [(ngModel)]="message" placeholder="Type a message" required>
  <button type="submit">Send</button>

  <li *ngFor="let message of messages">
    {{ message.name }}: {{ message.text }}

In the code above, we create a form with two input fields for the user to enter their name and message, and a button to submit the form. We also display all the messages received in a list using Angular's ngFor directive.

Now let's create our Angular component and service:

// chat.component.ts
import { Component } from '@angular/core';
import { ChatService } from './chat.service';

  selector: 'app-chat',
  templateUrl: './chat.component.html',
  styleUrls: ['./chat.component.css']
export class ChatComponent {
  name: string;
  message: string;
  messages: { name: string, text: string }[] = [];

  constructor(private chatService: ChatService) {}

  ngOnInit() {
    this.chatService.onMessage().subscribe((data) => {

  sendMessage(form: any) {
      name: form.name,
      text: form.message
    this.message = '';

// chat.service.ts
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { io } from 'socket.io-client';

  providedIn: 'root'
export class ChatService {
  private socket: any;

  connect() {
    this.socket = io('http://localhost:3000');

  disconnect() {

  onMessage(): Observable {
    return new Observable((observer) => {
      this.socket.on('message', (data: any) => {

  sendMessage(message: any) {
    this.socket.emit('message', message);

In the code above, we create an Angular component ChatComponent and a service ChatService. The component displays the chat form and messages list, and the service connects to the WebSocket server and provides methods for sending and receiving messages.

Now we're ready to start our Node.js server and Angular client. Run the following commands:

node server.js
ng serve

Open your web browser to http://localhost:4200 and try sending a message. You should see the message appear in the messages list in real-time, as shown below:

Angular chat application screenshot


In this guide, we learned about WebSockets and Socket.IO and how they enable fullstack developers to implement real-time communication in their web applications. We explored a practical example of building a real-time chat application using Node.js and Angular. Socket.IO provides a simple and effective way to add real-time capabilities to web applications, enabling users to interact and receive updates instantly without having to refresh the page.