What is middleware in Django?

middleware in Django
Photo by James Harrison on Unsplash

Django, which is a powerful web framework for Python, gets a lot of its strength from something called “middlewares.” Imagine middleware in Django as helpful assistants that manage how your web application deals with requests and responses.

Middlewares comes into play whenever there is a request to the Django server, middleware receives the request, do anything before it, calls the actual view, gets its response, and then performs anything after that.

There are some built-in middlewares and we could also add custom ones too. One great example is a middleware for logging, which we will code in a bit!

Here is a basic flow diagram for understanding middleware in django:


Built-in middleware in Django

These are the built-in middleware in Django. The order is important as these are triggered one by one. For every request that comes in, the request must pass through this list of middleware to access the relevant view.

For example, consider this middleware list:

    'corsheaders.middleware.CorsMiddleware', # consider CORS middleware


Let’s understand the ‘CorsMiddleware‘:

CORS middleware in Django allows websites to securely share data by adding special instructions to server responses. It specifies which external sites can access the data, what actions they’re allowed to perform, and whether they can include credentials. This helps prevent unauthorized access while enabling controlled data sharing between websites.

You might like: Exploring the pros and cons of python

Custom Middleware in Django

There are scenarios where we need to build a middleware. So, Now we will understand and look into the process of building a middleware:

Consider a scenario where you want to track the duration of each request, log user information, and capture any potential errors.

Implementation Details

Create a file named `logging_middleware.py` in your Django app.

Implement the middleware logic to capture request details, log information, and measure the request duration.

import time
import logging

class LoggingMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        start_time = time.time()
        response = self.get_response(request)
        end_time = time.time()
        duration = end_time - start_time

        # Log request details
            f"Method: {request.method}, Path: {request.path}, "
            f"Status Code: {response.status_code}, Duration: {duration:.2f} seconds"

        return response

Add the middleware to your `MIDDLEWARE` setting in the `settings.py` file.

    # Other middlewares...
    # ...

Run your Django application and test the logging middleware by making requests to different views. Check your application logs to ensure that the middleware captures and logs the relevant information.


 The key to effective middleware usage lies in thoughtful design, adherence to best practices, and continuous optimization. Whether you’re leveraging built-in middleware or crafting custom solutions, a solid understanding of this aspect of Django development will undoubtedly elevate your skills as a web developer.

Additional Resources and Further Reading:

  1. Django Official documentation on middleware
  2. How to Create a Custom Django Middleware
  3. A Comprehensive Guide to Django Middleware
Software Engineer | Website

Talha is a seasoned Software Engineer with a passion for exploring the ever-evolving world of technology. With a strong foundation in Python and expertise in web development, web scraping, and machine learning, he loves to unravel the intricacies of the digital landscape. Talha loves to write content on this platform for sharing insights, tutorials, and updates on coding, development, and the latest tech trends

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *