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

How to Implement WebSockets in Django?

Learn how to integrate WebSockets with Django using Django Channels for real-time communication. This detailed guide covers setup, implementation, and troubleshooting.

Introduction to Django WebSocket

In the ever-evolving landscape of web development, real-time communication has become an essential feature for modern applications. From chat applications and live notifications to collaborative tools and online gaming, real-time interactions enhance user experiences and engagement. One powerful technology that enables this real-time capability is WebSockets. Unlike traditional HTTP requests, WebSockets provide full-duplex communication, allowing data to be sent and received simultaneously.
Integrating WebSockets with Django, a high-level Python web framework, can significantly boost the real-time capabilities of your web applications. Django Channels, an extension of Django, facilitates handling WebSockets by providing the necessary tools to manage asynchronous communication. In this article, we'll explore how to set up and use Django Channels to create robust real-time applications using WebSockets.

Getting Started with Django WebSocket

Before diving into the implementation of WebSockets in Django, ensure you have Django installed and a basic understanding of the Django framework. Additionally, you'll need Django Channels and an ASGI server like Daphne or Uvicorn. Django Channels extends Django to handle asynchronous protocols such as WebSockets, allowing you to build real-time applications.

Setting Up Django Channels

Installation of Django Channels

To get started, install Django Channels using pip:


1pip install channels

Adding Channels to the Django Project

Next, add channels to your INSTALLED_APPS in the settings.py file:


2    # ...
3    'channels',

Configuring the ASGI Application

Update the settings.py file to configure the ASGI application:


1ASGI_APPLICATION = 'your_project_name.asgi.application'
Create an asgi.py file in your project directory to define the ASGI application:


1import os
2from django.core.asgi import get_asgi_application
3from channels.routing import ProtocolTypeRouter, URLRouter
4from channels.auth import AuthMiddlewareStack
5from your_app import routing
7os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project_name.settings')
9application = ProtocolTypeRouter({
10    "http": get_asgi_application(),
11    "websocket": AuthMiddlewareStack(
12        URLRouter(
13            routing.websocket_urlpatterns
14        )
15    ),

Configuring ASGI Server

Installing and Configuring Daphne

Install Daphne, an ASGI server, to serve your Django application:


1pip install daphne

Running the ASGI Server

Run the server using Daphne:


1daphne -p 8001 your_project_name.asgi:application

Updating Routing Configurations

Ensure that your routing configurations in routing.py are set up to handle WebSocket connections.

Creating a WebSocket Consumer

Writing a Basic WebSocket Consumer

Create a consumers.py file in your Django app directory and define a basic WebSocket consumer:


1# consumers.py
2from channels.generic.websocket import WebsocketConsumer
3import json
5class ChatConsumer(WebsocketConsumer):
6    def connect(self):
7        self.accept()
9    def disconnect(self, close_code):
10        pass
12    def receive(self, text_data):
13        text_data_json = json.loads(text_data)
14        message = text_data_json['message']
15        self.send(text_data=json.dumps({
16            'message': message
17        }))

Adding the Consumer to Routing

Add the consumer to your routing configuration in routing.py:


1# routing.py
2from django.urls import re_path
3from . import consumers
5websocket_urlpatterns = [
6    re_path(r'ws/chat/$', consumers.ChatConsumer.as_asgi()),

Frontend Integration with WebSocket

Writing JavaScript Code to Establish WebSocket Connection

To integrate WebSockets on the frontend, write JavaScript code that establishes a WebSocket connection. Add the following script to your HTML template:


1const chatSocket = new WebSocket(
2    'ws://' + window.location.host + '/ws/chat/'
5chatSocket.onmessage = function(e) {
6    const data = JSON.parse(e.data);
7    document.querySelector('#chat-log').value += (data.message + '\n');
11document.querySelector('#chat-message-input').onkeyup = function(e) {
12    if (e.keyCode === 13) {  // Enter key
13        const message = document.querySelector('#chat-message-input').value;
14        chatSocket.send(JSON.stringify({
15            'message': message
16        }));
17        document.querySelector('#chat-message-input').value = '';
18    }

Get Free 10,000 Minutes Every Months

No credit card required to start.

Advanced WebSocket Features

Broadcasting Messages to Multiple Clients

To broadcast messages to multiple clients, you can implement groups in Django Channels. This allows messages sent by one client to be received by all clients connected to the same group.

Implementing Groups for Chat Rooms

Update your ChatConsumer to handle groups:


1from asgiref.sync import async_to_sync
2from channels.layers import get_channel_layer
4class ChatConsumer(WebsocketConsumer):
5    def connect(self):
6        self.room_group_name = 'chat_group'
7        async_to_sync(self.channel_layer.group_add)(
8            self.room_group_name,
9            self.channel_name
10        )
11        self.accept()
13    def disconnect(self, close_code):
14        async_to_sync(self.channel_layer.group_discard)(
15            self.room_group_name,
16            self.channel_name
17        )
19    def receive(self, text_data):
20        text_data_json = json.loads(text_data)
21        message = text_data_json['message']
22        async_to_sync(self.channel_layer.group_send)(
23            self.room_group_name,
24            {
25                'type': 'chat_message',
26                'message': message
27            }
28        )
30    def chat_message(self, event):
31        message = event['message']
32        self.send(text_data=json.dumps({
33            'message': message
34        }))

Troubleshooting Common Issues

  • Check Server Logs: Monitor server logs for errors related to WebSocket connections.
  • Client-Side Console: Use browser developer tools to inspect WebSocket frames and debug issues.
  • Configuration Errors: Ensure all configurations, such as routing and ASGI settings, are correct.
  • Network Issues: Verify there are no network issues preventing WebSocket connections.
By following these steps, you can set up a Django project with real-time WebSocket communication, create WebSocket consumers, and integrate them with the frontend. The next section will provide a conclusion and address frequently asked questions.


Implementing WebSockets in Django through Django Channels opens up a world of real-time capabilities for your web applications. Whether you're building a chat application, live notifications, or any other real-time feature, WebSockets provide a robust and efficient solution. By following the steps outlined in this guide, you can set up Django Channels, create WebSocket consumers, and integrate them with your frontend seamlessly. Experiment with these tools to enhance your applications and provide dynamic, interactive user experiences. The power of real-time communication is now at your fingertips.

Want to level-up your learning? Subscribe now

Subscribe to our newsletter for more tech based insights