Custom response classes in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this FastAPI endpoint with a custom response class?

Consider this FastAPI endpoint using a custom response class:

from fastapi import FastAPI, Response

app = FastAPI()

class CustomTextResponse(Response):
    media_type = "text/custom"

@app.get("/custom", response_class=CustomTextResponse)
async def custom_response():
    return "Hello Custom!"

What will the client receive as the Content-Type header and body?

FastAPI

from fastapi import FastAPI, Response

app = FastAPI()

class CustomTextResponse(Response):
    media_type = "text/custom"

@app.get("/custom", response_class=CustomTextResponse)
async def custom_response():
    return "Hello Custom!"

A Content-Type: text/custom with body 'Hello Custom!'

B Content-Type: application/json with body '"Hello Custom!"'

C Content-Type: text/plain with body 'Hello Custom!'

D Content-Type: text/custom with empty body

💡 Hint

Check the media_type attribute in the custom response class.

The custom response class sets media_type to text/custom, so the response header Content-Type will be text/custom. The returned string is the body.

📝 Syntax

intermediate

Which option correctly defines a custom JSON response class in FastAPI?

You want to create a custom JSON response class that sets media_type to application/vnd.api+json. Which code snippet is correct?

A

class CustomJSONResponse(Response):
    media_type = "application/json"

    def render(self, content: Any) -> str:
        return json.dumps(content)

B

class CustomJSONResponse(JSONResponse):
    media_type = "application/vnd.api+json"

C

class CustomJSONResponse(Response):
    media_type = "application/vnd.api+json"

    def render(self, content: Any) -> bytes:
        import json
        return json.dumps(content).encode("utf-8")

D

class CustomJSONResponse(Response):
    media_type = "application/vnd.api+json"

    def render(self, content: Any) -> str:
        return json.dumps(content)

💡 Hint

FastAPI's JSONResponse already handles JSON encoding.

Option B correctly subclasses JSONResponse and overrides media_type. This reuses JSON encoding logic. Other options either miss encoding to bytes or use wrong return types.

🔧 Debug

advanced

Why does this custom response class cause a runtime error?

Examine this code snippet:

from fastapi import FastAPI, Response

app = FastAPI()

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

    def render(self, content):
        return content

@app.get("/test", response_class=MyResponse)
async def test():
    return "Hello"

What error will occur and why?

FastAPI

from fastapi import FastAPI, Response

app = FastAPI()

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

    def render(self, content):
        return content

@app.get("/test", response_class=MyResponse)
async def test():
    return "Hello"

A No error, returns plain text 'Hello'

B SyntaxError due to missing colon in render method

C TypeError because render must return bytes, not str

D RuntimeError because media_type is invalid

💡 Hint

Check the return type expected by render in FastAPI's Response classes.

The render method must return bytes, but here it returns a string. This causes a TypeError at runtime.

❓ state_output

advanced

What is the response body when using this custom XML response class?

Given this FastAPI app:

from fastapi import FastAPI, Response

app = FastAPI()

class XMLResponse(Response):
    media_type = "application/xml"

    def render(self, content: dict) -> bytes:
        xml = ""
        for key, value in content.items():
            xml += f"<{key}>{value}"
        xml += ""
        return xml.encode("utf-8")

@app.get("/xml", response_class=XMLResponse)
async def get_xml():
    return {"name": "Alice", "age": 30}

What will the client receive as the response body?

FastAPI

from fastapi import FastAPI, Response

app = FastAPI()

class XMLResponse(Response):
    media_type = "application/xml"

    def render(self, content: dict) -> bytes:
        xml = "<root>"
        for key, value in content.items():
            xml += f"<{key}>{value}</{key}>"
        xml += "</root>"
        return xml.encode("utf-8")

@app.get("/xml", response_class=XMLResponse)
async def get_xml():
    return {"name": "Alice", "age": 30}

A <root><name>Alice</name><age>30</age></root>

B <root>{"name": "Alice", "age": 30}</root>

C {"name": "Alice", "age": 30}

D <root><name>Alice</name><age>"30"</age></root>

💡 Hint

Look at how the render method builds the XML string.

The render method converts the dictionary to XML tags without quotes around values. So the output is <root><name>Alice</name><age>30</age></root>.

🧠 Conceptual

expert

Which statement about FastAPI custom response classes is TRUE?

Choose the correct statement about creating and using custom response classes in FastAPI.

A FastAPI automatically converts any return value to bytes, so <code>render</code> is optional.

B You can use any Python class as a response_class if it has a <code>media_type</code> attribute.

C Custom response classes can override <code>media_type</code> but cannot change the response body format.

D Custom response classes must always subclass <code>Response</code> and implement <code>render</code> returning bytes.

💡 Hint

Think about what FastAPI expects from response classes regarding data encoding.

FastAPI requires custom response classes to subclass Response and implement render that returns bytes. This ensures proper HTTP response formatting.