End of Life for Twilio Programmable Video - Upgrade to VideoSDKLearn More

How to Integrate Flask with Socket.IO?

Learn how to integrate Flask with Socket.IO for real-time communication. This comprehensive guide covers setup, event handling, advanced features, and deployment.


In the fast-paced world of web development, real-time communication has become a crucial feature for modern web applications. Whether it's for live chat systems, real-time notifications, or collaborative tools, the ability to push updates to clients instantly can significantly enhance user experience. Flask, a lightweight and flexible web framework for Python, combined with Socket.IO, a powerful library for real-time web applications, offers a seamless solution for integrating real-time capabilities into your web projects. This article explores how to set up and use Flask Socket.IO, guiding you through the essential steps to build a robust real-time web application.

Getting Started with Flask Socket.IO

Flask is a micro web framework written in Python, known for its simplicity and flexibility. It allows developers to build web applications quickly and easily. Socket.IO, on the other hand, is a JavaScript library that enables real-time, bidirectional, and event-based communication between web clients and servers. By integrating Flask with Socket.IO, you can create powerful real-time web applications that update the client-side instantly without requiring a page reload. This combination is particularly useful for applications like live chat, online gaming, and collaborative editing tools.

Setting Up the Environment

Before starting, ensure you have Python installed on your system. Additionally, you will need to install Flask and Flask-SocketIO packages. It is recommended to use a virtual environment to manage your project dependencies.

Installation Guide

To set up your environment, follow these steps:

[a] Install Python

Download and install Python from



[b] Create a virtual environment


1    python -m venv flask_socketio_env

[c] Activate the virtual environment

  • On Windows:


1      flask_socketio_env\Scripts\activate
  • On macOS/Linux:


1      source flask_socketio_env/bin/activate

[d] Install Flask and Flask-SocketIO


1    pip install flask flask-socketio

Building a Simple Flask Socket.IO Application

Creating the Flask Application

Start by creating a basic Flask application. Create a file named app.py and add the following code:


1from flask import Flask
3app = Flask(__name__)
6def index():
7    return "Hello, Flask Socket.IO!"
9if __name__ == '__main__':
10    app.run(debug=True)
This code initializes a simple Flask application with a single route that returns a welcome message.

Integrating Socket.IO

Next, integrate Socket.IO with your Flask app. Install Flask-SocketIO and update your app.py:


1from flask import Flask, render_template
2from flask_socketio import SocketIO
4app = Flask(__name__)
5socketio = SocketIO(app)
8def index():
9    return render_template('index.html')
11if __name__ == '__main__':
12    socketio.run(app, debug=True)

Handling Events

To handle events, you need to define event handlers. Update your app.py to include event handling:


1from flask import Flask, render_template
2from flask_socketio import SocketIO, send
4app = Flask(__name__)
5socketio = SocketIO(app)
8def index():
9    return render_template('index.html')
12def handleMessage(msg):
13    print('Message: ' + msg)
14    send(msg, broadcast=True)
16if __name__ == '__main__':
17    socketio.run(app, debug=True)
Create an index.html file in a templates directory with the following content:


1<!DOCTYPE html>
2<html lang="en">
4    <meta charset="UTF-8">
5    <title>Flask Socket.IO</title>
6    <script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>
7    <script>
8        document.addEventListener('DOMContentLoaded', (event) => {
9            var socket = io();
10            socket.on('connect', function() {
11                socket.send('User has connected!');
12            });
13            socket.on('message', function(msg) {
14                var p = document.createElement('p');
15                p.innerText = msg;
16                document.body.appendChild(p);
17            });
18        });
19    </script>
22    <h1>Flask Socket.IO</h1>

Advanced Features

Broadcasting Messages

Broadcasting messages allows you to send messages to all connected clients. This is useful for notifications and updates. Modify the handleMessage function to broadcast messages:


2def handleMessage(msg):
3    send(msg, broadcast=True)
This code ensures that any message received is broadcasted to all connected clients.

Rooms and Namespaces

Rooms and namespaces help organize your Socket.IO application. Rooms allow you to group clients, while namespaces provide a separation of concerns. Here’s how to use them:


2def on_join(data):
3    room = data['room']
4    join_room(room)
5    send('Someone has entered the room.', to=room)
8def on_leave(data):
9    room = data['room']
10    leave_room(room)
11    send('Someone has left the room.', to=room)

Error Handling

Handling errors gracefully is crucial. You can handle errors in Flask Socket.IO by catching exceptions and logging them:


1@socketio.on_error()        # Handles the default namespace
2def error_handler(e):
3    print(f'An error occurred: {e}')

Get Free 10,000 Minutes Every Months

No credit card required to start.

Deployment and Scaling

Deployment on a Production Server

Deploying Flask Socket.IO on a production server involves configuring a production-ready server like Gunicorn and using a reverse proxy like Nginx. Here’s a basic setup:

Install Gunicorn


1    pip install gunicorn

Run the app with Gunicorn


1    gunicorn --worker-class eventlet -w 1 app:app

Scaling with Multiple Workers

To handle more traffic, you can scale your application by running multiple workers. Update your Gunicorn command to start multiple workers:


1gunicorn --worker-class eventlet -w 4 app:app
This command starts four workers to handle incoming connections, improving the app’s scalability and performance.


Integrating Flask with Socket.IO provides a robust framework for building real-time web applications. From setting up your environment to deploying and scaling your application, this guide has covered the essential steps to get you started.
By leveraging the power of Flask and Socket.IO, you can create responsive, interactive web applications that enhance user experience through real-time communication. Experiment with the advanced features and continue to explore the possibilities of Flask Socket.IO to take your web development skills to the next level.

Want to level-up your learning? Subscribe now

Subscribe to our newsletter for more tech based insights