The jsonable_encoder runs in FastAPI's router layer before the response class is involved — it's part of how FastAPI processes the return value of your endpoint function. The only way to bypass it completely is to return a Response object directly from your endpoint.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import json

@app.get("/large")
async def large_endpoint():
    data = ["a"] * 10_000_000

    async def generate():
        yield json.dumps(data)

    return StreamingResponse(generate(), media_type="application/json")

When you return a Response subclass (including StreamingResponse) directly, FastAPI skips jsonable_encoder entirely — the router detects it's already a response and passes it through as-is.

On your second question — downsides of JSONStreamingResponse as default:

• You lose Pydantic response validation (as you noted)
• Response schema in OpenAPI docs may not reflect actual output
• No automatic serialization of custom types (datetimes, UUIDs, etc.)

For large payloads, returning StreamingResponse directly is the idiomatic approach. If you need it app-wide, a custom APIRoute class that wraps large return values in a streaming response is a cleaner abstraction than overriding the default response class.

I think this is expected behavior in FastAPI.

response_class controls how the final response is rendered, but FastAPI still processes a normal return value first. So when an endpoint returns:

return ["a"] * 10000000

FastAPI treats that as application data, runs the normal response serialization flow, and only then passes the result to the configured response class. That is why jsonable_encoder is still involved.

If you want to completely bypass jsonable_encoder, response model handling, and normal serialization, the endpoint needs to return a Response instance directly:

@app.get("/")
async def get_data():
    return JSONStreamingResponse(["a"] * 10000000)

or preferably stream/generate the data without building the entire list first:

@app.get("/")
async def get_data():
    async def generate():
        yield b"["
        first = True
        for item in some_large_iterator():
            if not first:
                yield b","
            first = False
            yield orjson.dumps(item)
        yield b"]"

    return StreamingResponse(generate(), media_type="application/json")

Using a streaming response as the default response class can work, but there are trade-offs:

• FastAPI may still serialize normal return values before your response class receives them
• response model validation/serialization behavior can be bypassed only when returning a Response directly
• if you build the full payload before streaming, memory usage is still high
• streaming JSON is harder to combine with response schemas/OpenAPI expectations
• error handling becomes trickier once bytes have started streaming

So the practical answer is: use StreamingResponse/custom Response directly in endpoints where you really need streaming. default_response_class is useful for rendering format, but it does not skip FastAPI’s serialization pipeline for normal Python return values.