Category: Uncategorized

Building a Python Django multi-vendor e-commerce platform is no longer a distant dream reserved for large enterprises. With Django’s “batteries‑included” philosophy, developers can launch a marketplace where dozens—or even thousands—of independent sellers showcase their products, manage orders, and receive payments, all while enjoying the scalability, security, and rapid development cycle that Django provides. In this guide we’ll explore the architectural pillars, essential features, and step‑by‑step development workflow needed to create a robust, SEO‑friendly marketplace that rivals commercial solutions.

Why Django Is the Ideal Choice for a Multi‑Vendor Marketplace

Django stands out for multi‑vendor e‑commerce projects for several compelling reasons:

• Rapid development: Built‑in admin, ORM, and authentication accelerate core functionality.
• Scalability: Horizontal scaling with Django’s support for multiple databases, caching layers, and async capabilities.
• Security: Out‑of‑the‑box protection against CSRF, XSS, SQL injection, and clickjacking.
• Extensibility: A rich ecosystem of reusable apps (e.g., django-oscar, django-shop) that can be customized for multi‑vendor needs.
• SEO friendliness: Clean URL routing, sitemap generation, and template tags make it easy to optimize for search engines.

Core Architecture of a Django Multi‑Vendor Platform

1. Data Model Design

The backbone of any marketplace is a well‑structured data model. Below is a simplified representation of the essential entities:

class Vendor(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    store_name = models.CharField(max_length=255)
    slug = models.SlugField(unique=True)
    # Additional fields: logo, description, rating, etc.

class Product(models.Model):
    vendor = models.ForeignKey(Vendor, related_name='products', on_delete=models.CASCADE)
    name = models.CharField(max_length=255)
    slug = models.SlugField()
    description = models.TextField()
    price = models.DecimalField(max_digits=10, decimal_places=2)
    inventory = models.PositiveIntegerField()
    # Images, categories, attributes, etc.

class Order(models.Model):
    buyer = models.ForeignKey(User, related_name='orders', on_delete=models.CASCADE)
    created_at = models.DateTimeField(auto_now_add=True)
    status = models.CharField(max_length=20, choices=ORDER_STATUS)
    # Shipping, payment, total amount, etc.

class OrderItem(models.Model):
    order = models.ForeignKey(Order, related_name='items', on_delete=models.CASCADE)
    product = models.ForeignKey(Product, on_delete=models.PROTECT)
    quantity = models.PositiveIntegerField()
    price_at_purchase = models.DecimalField(max_digits=10, decimal_places=2)

2. Separation of Concerns

• Vendor app: Handles registration, dashboard, product CRUD, and analytics.
• Shop app: Manages product browsing, cart, checkout, and order tracking for customers.
• Payments app: Integrates with Stripe, PayPal, or local gateways; supports split payments to vendors.
• Core app: Contains shared utilities, custom middleware, and SEO helpers.

Key Features Every Multi‑Vendor Marketplace Should Have

Vendor Management

• Self‑service onboarding with email verification.
• Vendor dashboard showing sales, earnings, and inventory alerts.
• Role‑based permissions (admin, vendor, staff).

Product Catalog

• Rich product attributes (size, color, digital download).
• Bulk import/export via CSV/Excel.
• Dynamic pricing rules (discounts, promotions).

Order & Shipping Workflow

• Separate order status per vendor (e.g., “Vendor A – Shipped”, “Vendor B – Pending”).
• Integrated shipping providers (Shippo, EasyPost) with real‑time rates.
• Automated email notifications for order confirmations, shipping updates, and refunds.

Payments & Payouts

• Marketplace‑mode payment processing (e.g., Stripe Connect).
• Commission configuration (percentage or fixed fee).
• Scheduled payouts to vendor bank accounts.

SEO & Marketing Tools

• SEO‑optimized URLs: /store/<vendor-slug>/product/<product-slug>/
• Automatic sitemap generation for vendors and products.
• OpenGraph and Twitter Card meta tags for social sharing.
• Schema.org markup for product rich snippets.

Step‑by‑Step Development Guide

Step 1 – Project Setup

python -m venv env
source env/bin/activate
pip install django djangorestframework pillow
django-admin startproject marketplace
cd marketplace
python manage.py startapp vendor
python manage.py startapp shop

Step 2 – Configure Settings

• Add 'vendor', 'shop', 'rest_framework' to INSTALLED_APPS.
• Set AUTH_USER_MODEL = 'auth.User' or create a custom user model for extended profiles.
• Enable CACHE (Redis) for product listings and cart sessions.

Step 3 – Build the Vendor Registration Flow

Use Django’s built‑in UserCreationForm and extend it with a VendorProfileForm. After successful registration, redirect the user to a vendor onboarding wizard that captures store details, tax information, and payment credentials.

Step 4 – Implement the Product API

Expose CRUD endpoints via Django REST Framework so vendors can manage inventory from a mobile app or third‑party integration.

class ProductViewSet(viewsets.ModelViewSet):
    serializer_class = ProductSerializer
    permission_classes = [IsAuthenticated, IsVendorOwner]

    def get_queryset(self):
        return Product.objects.filter(vendor=self.request.user.vendor)

Step 5 – Set Up Checkout & Split Payments

Integrate Stripe Connect using the official SDK. Create a payment intent that automatically transfers the vendor’s share to their Stripe account.

stripe.PaymentIntent.create(
    amount=order_total,
    currency='usd',
    payment_method_types=['card'],
    transfer_data={'destination': vendor.stripe_account_id},
)

Step 6 – Optimize for SEO

• Use django.contrib.sitemaps to generate sitemap.xml for every vendor and product.
• Leverage the django-meta package to inject meta titles, descriptions, and canonical tags.
• Implement robots.txt that disallows admin URLs while allowing product pages.

Step 7 – Deploy and Scale

Containerize the application with Docker, place it behind a reverse proxy (NGINX), and use a managed PostgreSQL service. Enable horizontal scaling with Kubernetes or a PaaS like Render, leveraging Django’s ALLOWED_HOSTS and SECURE_SSL_REDIRECT settings for production readiness.

Best Practices for Performance, Security, and Maintainability

• Cache heavy queries: Cache product listings for 5‑10 minutes using Redis; invalidate cache on inventory change.
• Use async views for external API calls (shipping rates, payment verification) to keep request latency low.
• Database indexing: Index vendor_id, slug, and created_at fields for fast lookups.
• Rate limiting: Apply django-ratelimit on registration and login endpoints to mitigate brute‑force attacks.
• Regular backups: Schedule daily PostgreSQL dumps and store them in a secure object storage (AWS S3, Google Cloud).
• Code quality: Enforce PEP‑8 compliance with flake8, run unit tests with pytest‑django, and maintain CI/CD pipelines.

Popular Django Packages that Accelerate Marketplace Development

• django-oscar – A modular e‑commerce framework that can be extended for multi‑vendor logic.
• django-mptt – Handles hierarchical categories and tree structures efficiently.
• django-tenant-schemas – Enables true multi‑tenant isolation if you need separate schemas per vendor.
• django-celery-beat – Schedules periodic tasks such as daily sales reports and payout processing.
• django-ckeditor – Provides a rich text editor for vendor product descriptions.

SEO Tips Specific to a Multi‑Vendor Marketplace

<

Building a robust authentication system is one of the first challenges you face when starting a new Django project. While Django’s default User model works well for many simple applications, real‑world projects often require additional fields, different login identifiers, or custom permission logic. That’s where a custom user model comes in. In this comprehensive guide we’ll walk through every step of creating, configuring, and maintaining a custom user model in Django, complete with code snippets, best‑practice tips, and common pitfalls to avoid.

Why Choose a Custom User Model?

Before diving into the implementation, it’s important to understand why you might need a custom user model instead of extending the built‑in one.

• Additional profile data: Store phone numbers, avatars, or subscription status directly on the user record.
• Alternative authentication fields: Use email, phone number, or a UUID as the primary login identifier.
• Custom permissions or roles: Implement role‑based access control that differs from Django’s default groups.
• Future‑proofing: Adding a custom model at project start saves you from costly migrations later.

Because Django reads the user model configuration at startup, you must define your custom model before you run the first migrate. Switching later is possible but requires careful data migration and can be error‑prone.

Step‑by‑Step: Creating a Custom User Model

1. Set Up a Dedicated App

It’s a best practice to keep authentication logic isolated in its own app, for example accounts.

django-admin startapp accounts

2. Define a Custom User Manager

The manager handles user creation and ensures the required fields are set correctly. Use BaseUserManager as the parent class.

from django.contrib.auth.base_user import BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)

        if extra_fields.get('is_staff') is not True or \
           extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_staff=True and is_superuser=True')
        return self.create_user(email, password, **extra_fields)

3. Build the Custom User Model

Extend AbstractBaseUser and PermissionsMixin to inherit password handling and permission utilities.

from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
from django.utils import timezone

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField('email address', unique=True)
    first_name = models.CharField('first name', max_length=30, blank=True)
    last_name = models.CharField('last name', max_length=30, blank=True)
    date_joined = models.DateTimeField('date joined', default=timezone.now)
    is_active = models.BooleanField('active', default=True)
    is_staff = models.BooleanField('staff status', default=False)

    objects = CustomUserManager()

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = []  # Email & password are required by default

    class Meta:
        verbose_name = 'user'
        verbose_name_plural = 'users'

    def __str__(self):
        return self.email

4. Tell Django About the New Model

Add the following line to your project’s settings.py before any app that imports django.contrib.auth:

AUTH_USER_MODEL = 'accounts.CustomUser'

5. Register the Model in the Admin Interface

Customizing the admin makes user management seamless for staff.

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
from .models import CustomUser
from .forms import CustomUserCreationForm, CustomUserChangeForm

class CustomUserAdmin(BaseUserAdmin):
    add_form = CustomUserCreationForm
    form = CustomUserChangeForm
    model = CustomUser
    list_display = ('email', 'first_name', 'last_name', 'is_staff')
    list_filter = ('is_staff', 'is_active')
    fieldsets = (
        (None, {'fields': ('email', 'password')}),
        ('Personal info', {'fields': ('first_name', 'last_name')}),
        ('Permissions', {'fields': ('is_staff', 'is_active', 'groups', 'user_permissions')}),
        ('Important dates', {'fields': ('last_login', 'date_joined')}),
    )
    add_fieldsets = (
        (None, {
            'classes': ('wide',),
            'fields': ('email', 'password1', 'password2', 'is_staff', 'is_active')}
        ),
    )
    search_fields = ('email',)
    ordering = ('email',)

admin.site.register(CustomUser, CustomUserAdmin)

6. Create Custom Forms (Optional but Recommended)

Using dedicated forms ensures proper validation for the admin and any registration views.

from django import forms
from django.contrib.auth.forms import UserCreationForm, UserChangeForm
from .models import CustomUser

class CustomUserCreationForm(UserCreationForm):
    class Meta:
        model = CustomUser
        fields = ('email',)

class CustomUserChangeForm(UserChangeForm):
    class Meta:
        model = CustomUser
        fields = ('email', 'first_name', 'last_name')

Running Migrations

Now that the model is defined, create and apply migrations.

python manage.py makemigrations accounts
python manage.py migrate

If you’re starting a fresh project, the migration will create the accounts_customuser table. For existing projects, consider using a data migration to copy data from auth_user to the new table before dropping the old model.

Using the Custom User Model in Your Code

Authentication Backends

The default authentication backend works out of the box because it relies on AUTH_USER_MODEL. However, if you need to authenticate with a phone number or a third‑party token, create a custom backend:

from django.contrib.auth.backends import ModelBackend
from django.contrib.auth import get_user_model

User = get_user_model()

class EmailOrPhoneBackend(ModelBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        try:
            user = User.objects.get(email=username)  # or phone_number=username
        except User.DoesNotExist:
            return None
        if user.check_password(password):
            return user
        return None

Then add it to AUTHENTICATION_BACKENDS in settings.py.

Referencing the User Model

Never import the model directly with from accounts.models import CustomUser in reusable apps. Use Django’s helper:

from django.contrib.auth import get_user_model
User = get_user_model()

This approach respects the AUTH_USER_MODEL setting and keeps your code portable.

Testing Your Custom User Model

Write unit tests to guarantee that user creation, authentication, and admin integration behave as expected.

from django.test import TestCase
from django.contrib.auth import get_user_model

User = get_user_model()

class CustomUserModelTests(TestCase):
    def test_create_user_with_email(self):
        user = User.objects.create_user(email='test@example.com', password='test123')
        self.assertEqual(user.email, 'test@example.com')
        self.assertTrue(user.check_password('test123'))
        self.assertFalse(user.is_staff)

    def test_create_superuser(self):
        admin = User.objects.create_superuser(email='admin@example.com', password='admin123')
        self.assertTrue(admin.is_staff)
        self.assertTrue(admin.is_superuser)

Common Pitfalls & How to Avoid Them

• Changing the user model after migrations: If you forget to set AUTH_USER_MODEL before the first migration, you’ll need to create a new database or perform a complex data migration.
• Hard‑coding the model name in foreign keys: Use settings.AUTH_USER_MODEL in ForeignKey definitions, e.g. author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE).
• Missing manager methods: Forgetting to implement create_superuser will break the createsuperuser command.
• Admin registration errors: Ensure the admin form classes reference the custom model; otherwise you’ll see “User has no attribute ‘username’”.
• Third‑party packages: Some older packages still assume username exists. Check their documentation or fork them to use email instead.

Best Practices Checklist

1. Define the custom model before running manage.py migrate.
2. Always reference the user model via get_user_model() or settings.AUTH_USER_MODEL.
3. Provide a dedicated
   

Looking to turn your Django web applications into powerful, scalable APIs? The Django REST Framework (DRF) makes it effortless to build robust RESTful services with minimal boiler‑plate. In this step‑by‑step tutorial we’ll walk through everything you need to know—from setting up a clean development environment to deploying a production‑ready API—so you can start delivering data to mobile apps, single‑page front‑ends, or third‑party services in no time.

What is Django REST Framework?

Django REST Framework (often abbreviated as DRF) is a flexible, open‑source toolkit that extends Django’s core capabilities to support the creation of Web APIs. It provides:

• Powerful Serializer classes for converting complex data types to JSON.
• Class‑based ViewSet and generic views that reduce repetitive code.
• Automatic URL routing via DefaultRouter.
• Built‑in authentication, permissions, throttling, pagination, and content negotiation.
• Comprehensive browsable API for rapid debugging.

Because DRF sits on top of Django, you retain all of Django’s strengths—ORM, admin, middleware—while gaining a modern API layer.

Setting Up the Development Environment

Prerequisites

Before diving in, make sure you have the following installed on your machine:

1. Python 3.9+ (the latest stable release is recommended).
2. pip, the Python package manager.
3. virtualenv or python -m venv for isolated environments.
4. Git (optional but useful for version control).

Creating a Virtual Environment

python -m venv drf-tutorial-env
source drf-tutorial-env/bin/activate   # On Windows use `drf-tutorial-env\Scripts\activate`
pip install --upgrade pip

Installing Django and DRF

pip install django djangorestframework

Verify the installation:

python -m django --version
# Should output something like 5.0.2

Creating a New Django Project

Run the standard Django start‑project command and create an app called api where our API logic will live.

django-admin startproject mysite
cd mysite
python manage.py startapp api

Next, register the app and DRF in mysite/settings.py:

INSTALLED_APPS = [
    # Default Django apps...
    'rest_framework',
    'api',
]

Building Your First API

Defining a Simple Model

Let’s create a Book model that stores basic bibliographic data.

# api/models.py
from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published = models.DateField()
    isbn = models.CharField(max_length=13, unique=True)

    def __str__(self):
        return f"{self.title} by {self.author}"

Run migrations to create the table:

python manage.py makemigrations api
python manage.py migrate

Serializers: Bridging Models and JSON

A serializer translates model instances into JSON and validates incoming data.

# api/serializers.py
from rest_framework import serializers
from .models import Book

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = ['id', 'title', 'author', 'published', 'isbn']

ViewSets: CRUD Operations in One Class

DRF’s ModelViewSet gives you a full set of create, retrieve, update, and delete (CRUD) actions with just a few lines.

# api/views.py
from rest_framework import viewsets
from .models import Book
from .serializers import BookSerializer

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer

Routing with DefaultRouter

The router automatically generates URL patterns for the viewset.

# api/urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import BookViewSet

router = DefaultRouter()
router.register(r'books', BookViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

Don’t forget to include the app’s URLs in the project’s root urls.py:

# mysite/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('api.urls')),  # <‑‑ API endpoint
]

Testing the API Locally

Start the development server and explore the browsable API at http://127.0.0.1:8000/api/books/:

python manage.py runserver

The interface lets you list books, add new entries, and edit or delete existing ones—all without leaving your browser.

Adding Authentication and Permissions

For production APIs you’ll want to restrict access. DRF ships with several authentication schemes; we’ll enable token authentication.

Install the token package

pip install djangorestframework-simplejwt

Configure settings

# mysite/settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ),
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
}

Create token endpoints

# mysite/urls.py (add the following)
from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
)

urlpatterns += [
    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

Now, only users with a valid JWT can access /api/books/. You can further fine‑tune permissions per viewset by overriding permission_classes.

Pagination, Filtering, and Ordering

Large collections need efficient navigation. DRF makes pagination a one‑line configuration.

Enable pagination

# mysite/settings.py
REST_FRAMEWORK.update({
    'PAGE_SIZE': 10,
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',
})

Filtering and ordering

# api/views.py (add imports)
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework import filters

class BookViewSet(viewsets.ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    filter_backends = [DjangoFilterBackend, filters.OrderingFilter, filters.SearchFilter]
    filterset_fields = ['author', 'published']
    ordering_fields = ['title', 'published']
    search_fields = ['title', 'author']

Install the filter backend:

pip install django-filter

Now you can query /api/books/?author=Jane%20Austen&ordering=-published to get sorted results.

Automated Testing with Django’s Test Client

Writing tests guarantees that future changes won’t break your API.

# api/tests.py

from django.urls import reverse

from rest_framework import status

from rest_framework.test import APITestCase

from .models import Book

from django.contrib.auth.models import User

from rest_framework_simplejwt.tokens import RefreshToken

class BookAPITest(APITestCase):

    def setUp(self):

        self.user = User.objects.create_user(username='tester', password='secret')

        refresh = RefreshToken.for_user(self.user)

        self.client.credentials(HTTP_AUTHORIZATION=f'Bearer {refresh.access_token}')
        self.book = Book.objects.create(

            title='Pride and Prejudice',

            author='Jane Austen',

            published='1813-01-28',

            isbn='1112223334445'

        )
    def test_list_books(self):

        url = reverse('book-list')  # auto‑generated by router

        response = self.client.get(url)

        self.assertEqual(response.status_code, status.HTTP_200_OK)

        self.assertEqual(response.data['count'], 1)
    def test_create_book(self):

        url = reverse('book-list')

        data = {

            'title': 'Emma',

            'author': 'Jane Austen',

            'published': '1815-12-23',

            'isbn':

Building a real‑time chat application is a classic way to showcase the power of Python Flask combined with Socket.IO. Whether you’re a beginner looking to dip your toes into WebSockets or an experienced developer aiming to add live communication features to an existing Flask project, this guide will walk you through every step—from setting up the environment to deploying a production‑ready chat server. By the end of the article, you’ll have a fully functional, SEO‑friendly chat app that you can extend with user authentication, message persistence, and more.

Why Choose Flask + SocketIO for Real‑Time Chat?

Flask is lightweight, flexible, and has a thriving ecosystem of extensions. When paired with Flask‑SocketIO, it gains native support for WebSocket communication, allowing bi‑directional data flow between the client and server without the overhead of constant HTTP polling. Here are the top reasons developers love this stack:

• Simplicity: Minimal boilerplate code and clear routing.
• Scalability: Works with asynchronous workers (eventlet or gevent) for high‑throughput scenarios.
• Extensibility: Easy integration with Flask extensions like Flask‑Login, Flask‑SQLAlchemy, and Flask‑Migrate.
• Cross‑platform: Runs on any OS that supports Python, and the client side works in all modern browsers.

Prerequisites and Project Setup

System Requirements

1. Python 3.9+ installed.
2. Virtual environment tool (venv or conda).
3. Basic knowledge of HTML, CSS, and JavaScript.

Creating the Project Structure

Start by creating a clean directory layout. This structure keeps templates, static assets, and server code organized.

my_chat_app/
├── app.py
├── requirements.txt
├── static/
│   ├── css/
│   │   └── style.css
│   └── js/
│       └── chat.js
└── templates/
    └── index.html

Installing Dependencies

Run the following commands inside your virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install Flask Flask-SocketIO eventlet
pip freeze > requirements.txt

Building the Flask Backend

Initializing Flask and SocketIO

In app.py, import the necessary modules and create the Flask app instance. We’ll use eventlet as the asynchronous worker because it’s lightweight and integrates seamlessly with Flask‑SocketIO.

from flask import Flask, render_template
from flask_socketio import SocketIO, emit, join_room, leave_room

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'  # Replace with a secure key in production

# Initialize SocketIO with eventlet async mode
socketio = SocketIO(app, async_mode='eventlet')

Defining Routes and Event Handlers

The main route renders the chat UI, while SocketIO events handle user connections, messages, and room management.

@app.route('/')
def index():
    return render_template('index.html')


@socketio.on('connect')
def handle_connect():
    emit('status', {'msg': 'You are connected!'})
    print('Client connected')


@socketio.on('join')
def on_join(data):
    username = data['username']
    room = data['room']
    join_room(room)
    emit('status', {'msg': f'{username} has entered the room.'}, room=room)


@socketio.on('message')
def handle_message(data):
    room = data['room']
    emit('message', data, room=room)


@socketio.on('leave')
def on_leave(data):
    username = data['username']
    room = data['room']
    leave_room(room)
    emit('status', {'msg': f'{username} has left the room.'}, room=room)

Running the Application

At the bottom of app.py, add the entry point that starts the server with eventlet support.

if __name__ == '__main__':
    socketio.run(app, host='0.0.0.0', port=5000, debug=True)

Crafting the Front‑End Interface

HTML Template (templates/index.html)

The template includes a simple UI for entering a username, selecting a chat room, and sending messages. It also loads the Socket.IO client library from a CDN.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask SocketIO Real‑Time Chat</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
    <script src="https://cdn.socket.io/4.7.2/socket.io.min.js"></script>
</head>
<body>
    <div class="chat-container">
        <h2>Real‑Time Chat</h2>
        <div id="status"></div>
        <div id="messages" class="messages"></div>
        <form id="chat-form">
            <input type="text" id="username" placeholder="Your name" required>
            <input type="text" id="room" placeholder="Room name" required>
            <button type="submit">Join Room</button>
        </form>
        <form id="message-form" style="display:none;">
            <input type="text" id="msg" autocomplete="off" placeholder="Type a message..." required>
            <button type="submit">Send</button>
            <button type="button" id="leave-btn">Leave</button>
        </form>
    </div>
    <script src="{{ url_for('static', filename='js/chat.js') }}"></script>
</body>
</html>

Client‑Side JavaScript (static/js/chat.js)

The script establishes a Socket.IO connection, handles UI events, and updates the chat log in real time.

document.addEventListener('DOMContentLoaded', () => {
    const socket = io();

    const statusDiv = document.getElementById('status');
    const messagesDiv = document.getElementById('messages');
    const chatForm = document.getElementById('chat-form');
    const messageForm = document.getElementById('message-form');
    const leaveBtn = document.getElementById('leave-btn');

    let currentRoom = '';
    let username = '';

    // Helper to append messages
    const addMessage = (msg, type = 'msg') => {
        const p = document.createElement('p');
        p.className = type;
        p.textContent = msg;
        messagesDiv.appendChild(p);
        messagesDiv.scrollTop = messagesDiv.scrollHeight;
    };

    // SocketIO event listeners
    socket.on('connect', () => addMessage('Connected to server.', 'status'));

    socket.on('status', data => addMessage(data.msg, 'status'));

    socket.on('message', data => {
        addMessage(`${data.username}: ${data.msg}`);
    });

    // Join room
    chatForm.addEventListener('submit', e => {
        e.preventDefault();
        username = document.getElementById('username').value.trim();
        currentRoom = document.getElementById('room').value.trim();
        if (username && currentRoom) {
            socket.emit('join', {username, room: currentRoom});
            chatForm.style.display = 'none';
            messageForm.style.display = 'flex';
        }
    });

    // Send message
    messageForm.addEventListener('submit', e => {
        e.preventDefault();
        const msgInput = document.getElementById('msg');
        const msg = msgInput.value.trim();
        if (msg) {
            socket.emit('message', {username, room: currentRoom, msg});
            msgInput.value = '';
        }
    });

    // Leave room
    leaveBtn.addEventListener('click', () => {
        socket.emit('leave', {username, room: currentRoom});
        messageForm.style.display = 'none';
        chatForm.style.display = 'flex';
        messagesDiv.innerHTML = '';
    });
});

Basic Styling (static/css/style.css)

Keep the UI clean and responsive with a few CSS rules.

body {

    font-family: Arial, Helvetica, sans-serif;

    background: #f4f7f9;

    margin: 0;

    padding: 20px;

}

.chat-container {

    max-width: 600px;

    margin: auto;

    background: #fff;

    border-radius: 8px;

    padding: 20px;

    box-shadow: 0 2px 8px rgba(0,0,0,0.1);

}

h2 { text-align: center; }

#messages {

    height: 300px;

    overflow-y: auto;

    border: 1px solid #ddd;

    padding: 10px;

    margin-bottom: 10px;

}

#messages p { margin: 5px 0; }

p.status { color: #555; font-style: italic; }

form { display: flex; gap: 10px; }

input[type="text"] { flex: 1; padding: 8px; }

button { padding: 8px 12px; }