Fix RuntimeError: RuntimeError: No response returned from ASGI application in FastAPI

This error occurs when custom middleware does not properly call the next middleware or return a response, breaking the ASGI chain. Fix it by ensuring your middleware calls call_next(request) and returns the response object. If using BaseHTTPMiddleware, the dispatch method must return the response from call_next.

Reading the Stack Trace

Here's what each line means:

• File "/app/src/middleware/logging_middleware.py", line 15, in dispatch: The custom middleware logs the request but does not call call_next() to pass the request to the next handler in the chain.
• File "/app/venv/lib/python3.11/site-packages/starlette/middleware/base.py", line 68, in __call__: Starlette's BaseHTTPMiddleware expects the dispatch method to return a Response, but received None.
• RuntimeError: No response returned from ASGI application: The ASGI server received no response because the middleware broke the request/response chain.

Common Causes

from starlette.middleware.base import BaseHTTPMiddleware
import logging

logger = logging.getLogger(__name__)

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        logger.info(f"Request: {request.method} {request.url}")
        # Missing: response = await call_next(request)
        # Missing: return response

class TimingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        start = time.time()
        response = await call_next(request)
        duration = time.time() - start
        logger.info(f"Duration: {duration:.3f}s")
        # Missing: return response

class AuthMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        api_key = request.headers["X-API-Key"]  # KeyError if missing
        if not validate_key(api_key):
            raise ValueError("Invalid key")
        response = await call_next(request)
        return response

The Fix

Ensure the dispatch method always calls await call_next(request) to pass the request down the middleware chain and always returns the resulting Response object. Adding a return type annotation helps catch this mistake during development.

from starlette.middleware.base import BaseHTTPMiddleware
import logging

logger = logging.getLogger(__name__)

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        logger.info(f"Request: {request.method} {request.url}")

from starlette.middleware.base import BaseHTTPMiddleware
from starlette.responses import Response
import logging
import time

logger = logging.getLogger(__name__)

class LoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next) -> Response:
        start = time.time()
        logger.info(f"Request: {request.method} {request.url}")
        response = await call_next(request)
        duration = time.time() - start
        response.headers["X-Process-Time"] = f"{duration:.3f}"
        logger.info(f"Response: {response.status_code} in {duration:.3f}s")
        return response

Testing the Fix

import pytest
from fastapi.testclient import TestClient
from app.main import app

client = TestClient(app)


def test_middleware_returns_response():
    response = client.get("/health")
    assert response.status_code == 200


def test_middleware_adds_process_time_header():
    response = client.get("/health")
    assert "x-process-time" in response.headers
    assert float(response.headers["x-process-time"]) >= 0


def test_middleware_does_not_break_post_requests():
    response = client.post("/api/data", json={"key": "value"})
    assert response.status_code in (200, 201, 422)
    assert "x-process-time" in response.headers


def test_middleware_handles_404():
    response = client.get("/nonexistent")
    assert response.status_code == 404
    assert "x-process-time" in response.headers

Run your tests:

pytest tests/test_middleware.py -v

Pushing Through CI/CD

git checkout -b fix/fastapi-middleware,git add src/middleware/logging_middleware.py tests/test_middleware.py,git commit -m "fix: add call_next and return response in logging middleware dispatch",git push origin fix/fastapi-middleware

Your CI config should look something like this:

name: CI
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
          cache: 'pip'
      - run: pip install -r requirements.txt
      - run: pytest --tb=short -q

The Full Manual Process: 18 Steps

Here's every step you just went through to fix this one bug:

1. Notice the error alert or see it in your monitoring tool
2. Open the error dashboard and read the stack trace
3. Identify the file and line number from the stack trace
4. Open your IDE and navigate to the file
5. Read the surrounding code to understand context
6. Reproduce the error locally
7. Identify the root cause
8. Write the fix
9. Run the test suite locally
10. Fix any failing tests
11. Write new tests covering the edge case
12. Run the full test suite again
13. Create a new git branch
14. Commit and push your changes
15. Open a pull request
16. Wait for code review
17. Merge and deploy to production
18. Monitor production to confirm the error is resolved

Total time: 30-60 minutes. For one bug.

pip install bugstack

import bugstack

bugstack.init(api_key=os.environ["BUGSTACK_API_KEY"])

Deploying the Fix (Manual Path)

1. Run the test suite locally to confirm middleware passes requests through correctly.
2. Open a pull request with the middleware fix.
3. Wait for CI checks to pass on the PR.
4. Have a teammate review and approve the PR.
5. Merge to main and verify all endpoints respond correctly in staging.

Frequently Asked Questions