Custom response classes in FastAPI - Step-by-Step Execution

Concept Flow - Custom response classes

Define Custom Response Class

↓

Use Custom Response in Path Operation

↓

Request Received

↓

Path Operation Executes

↓

Custom Response Class Formats Data

↓

Send Formatted Response to Client

This flow shows how you define a custom response class, use it in a route, and how FastAPI sends the formatted response to the client.

Execution Sample

FastAPI

from fastapi import FastAPI, Response

app = FastAPI()

class PlainTextResponse(Response):
    media_type = "text/plain"

@app.get("/hello", response_class=PlainTextResponse)
async def hello():
    return "Hello, friend!"

This code defines a custom plain text response class and uses it in a FastAPI route to return plain text instead of JSON.

Execution Table

Step	Action	Input/State	Output/State
1	Define PlainTextResponse class	None	Class with media_type='text/plain' created
2	Define /hello route with response_class=PlainTextResponse	None	Route ready to return plain text
3	Client sends GET request to /hello	Request received	Path operation triggered
4	Execute hello() function	No input params	Returns string 'Hello, friend!'
5	FastAPI uses PlainTextResponse to format response	String 'Hello, friend!'	Response body set to 'Hello, friend!' with Content-Type 'text/plain'
6	Send response to client	Formatted response	Client receives plain text 'Hello, friend!'
7	End	Response sent	Request cycle complete

💡 Request cycle ends after sending the formatted plain text response to the client

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
response_class	None	PlainTextResponse	PlainTextResponse	PlainTextResponse
return_value	None	"Hello, friend!"	"Hello, friend!"	"Hello, friend!"
response_body	None	None	"Hello, friend!"	"Hello, friend!"
content_type	None	None	"text/plain"	"text/plain"

Key Moments - 2 Insights

Why does the response have Content-Type 'text/plain' instead of 'application/json'?

Because the custom response class PlainTextResponse sets media_type to 'text/plain', FastAPI uses it to set the Content-Type header as shown in execution_table step 5.

What happens if you don't specify response_class in the route decorator?

FastAPI defaults to JSONResponse, so the output would be JSON formatted, not plain text. This is implied by the difference in step 2 where response_class is set.

Visual Quiz - 3 Questions

Look at the execution table, what is the response_body after step 5?

A "Hello, friend!"

B None

C An empty string

D A JSON object

💡 Hint

Check the 'response_body' variable in variable_tracker after step 5

At which step does FastAPI set the Content-Type header to 'text/plain'?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look at the 'Action' and 'Output/State' columns in execution_table step 5

If you remove the response_class=PlainTextResponse from the route, what changes in the response?

A Response will be HTML

B Response will be JSON with Content-Type 'application/json'

C Response will be plain text anyway

D Response will cause an error

💡 Hint

Refer to key_moments about default response_class behavior

Concept Snapshot

Custom response classes in FastAPI let you control how data is sent back.
Define a class inheriting Response and set media_type.
Use response_class parameter in route decorator.
FastAPI uses it to format and set Content-Type.
Useful for plain text, HTML, or other formats.

Full Transcript

This visual execution shows how FastAPI handles custom response classes. First, you define a class inheriting from Response and set the media_type to the desired content type, like 'text/plain'. Then, you use this class in a route with the response_class parameter. When a client requests that route, FastAPI runs the function, gets the return value, and uses the custom response class to format the output and set the Content-Type header accordingly. The response is then sent back to the client as plain text instead of JSON. This process helps you control exactly how your API sends data.