FastAPI middleware with BaseHTTPMiddleware — avoid for high-throughput

BaseHTTPMiddleware is convenient but has a known performance issue: it buffers the entire response body in memory before passing it through, breaking streaming responses and adding overhead.

For simple middleware (adding headers, logging), use BaseHTTPMiddleware carefully. For streaming or high-performance needs, implement a pure ASGI middleware instead.

# Simple middleware — acceptable for non-streaming
from starlette.middleware.base import BaseHTTPMiddleware

class TimingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        import time
        start = time.time()
        response = await call_next(request)
        response.headers['X-Process-Time'] = str(time.time() - start)
        return response

# Pure ASGI middleware — no buffering, streaming-safe
class RawASGIMiddleware:
    def __init__(self, app):
        self.app = app

    async def __call__(self, scope, receive, send):
        if scope['type'] == 'http':
            # Modify scope/receive/send as needed
            pass
        await self.app(scope, receive, send)

BaseHTTPMiddleware wraps the ASGI interface with a Request/Response abstraction. To expose a Response object, Starlette must fully buffer the body. Pure ASGI middleware operates on the raw send/receive callables and can stream data without buffering.

Adding cross-cutting concerns like logging, timing, or header injection to FastAPI