Why middleware processes requests globally in FastAPI

Introduction

Middleware runs for every request to handle common tasks like logging or security. It works globally so you don't repeat code in each route.

You want to log every request your app receives.

You need to check user authentication on all routes.

You want to add headers to every response.

You want to measure how long each request takes.

You want to handle errors in a central place.

Syntax

FastAPI

from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware

app = FastAPI()

class CustomMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        # Code before request
        response = await call_next(request)
        # Code after request
        return response

app.add_middleware(CustomMiddleware)

Middleware classes must implement a dispatch method.

The call_next function calls the next step in the request chain.

Examples

This middleware prints the path of every request before continuing.

FastAPI

from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware

app = FastAPI()

class LogMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        print(f"Request path: {request.url.path}")
        response = await call_next(request)
        return response

app.add_middleware(LogMiddleware)

This middleware adds a custom header to every response.

FastAPI

from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware

app = FastAPI()

class AddHeaderMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        response = await call_next(request)
        response.headers["X-Custom-Header"] = "MyValue"
        return response

app.add_middleware(AddHeaderMiddleware)

Sample Program

This example adds middleware that measures and prints how long each request takes. It runs for every request globally.

FastAPI

from fastapi import FastAPI
from starlette.middleware.base import BaseHTTPMiddleware
from starlette.requests import Request
from starlette.responses import Response

app = FastAPI()

class TimerMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        import time
        start = time.time()
        response: Response = await call_next(request)
        duration = time.time() - start
        print(f"Request took {duration:.4f} seconds")
        return response

app.add_middleware(TimerMiddleware)

@app.get("/")
async def root():
    return {"message": "Hello World"}

Important Notes

Middleware runs before and after every request automatically.

Use middleware for tasks that apply to all routes to avoid repeating code.

Middleware order matters: it runs in the order added.

Summary

Middleware processes requests globally to handle shared tasks.

This avoids repeating code in each route handler.

Middleware runs before and after every request automatically.