Response model declaration in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

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

Consider this FastAPI code snippet. What will the client receive when calling the endpoint?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    id: int
    name: str
    password: str

class UserResponse(BaseModel):
    id: int
    name: str

@app.get('/user', response_model=UserResponse)
async def get_user():
    return User(id=1, name='Alice', password='secret')

A {"id": 1, "name": "Alice", "password": "secret"}

B HTTP 500 Internal Server Error

C {"id": 1, "name": "Alice"}

D {"password": "secret"}

💡 Hint

Think about what the response_model does to the returned data.

The response_model tells FastAPI to filter the output to only include the fields declared in UserResponse. So the password field is excluded from the response sent to the client.

📝 Syntax

intermediate

Which option correctly declares a response model for a list of items in FastAPI?

You want to return a list of UserResponse models from a FastAPI endpoint. Which code snippet correctly declares the response model?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class UserResponse(BaseModel):
    id: int
    name: str

@app.get('/users', response_model=??? )
async def get_users():
    return [UserResponse(id=1, name='Alice'), UserResponse(id=2, name='Bob')]

A List[UserResponse]

B userResponse[]

C list(UserResponse)

D [UserResponse]

💡 Hint

Use Python's typing module for type hints.

FastAPI expects the response_model to be a type hint. For lists, use List[Model]. The other options are invalid syntax or not recognized types.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error despite correct response_model?

Examine the code and identify why a validation error occurs when returning the data.

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get('/item', response_model=Item)
async def get_item():
    return {"name": "Book", "price": "free"}

A The endpoint is missing async keyword causing runtime error.

B The response_model is missing a required field.

C The return type is a dict instead of an Item instance, causing type error.

D The price field is a string 'free' but should be a float, causing validation error.

💡 Hint

Check the data types of returned values against the model fields.

Pydantic validates the returned data against the response_model. The price field expects a float but got a string 'free', so validation fails.

❓ state_output

advanced

What is the output when using response_model with orm_mode enabled?

Given this FastAPI code using an ORM model, what will the client receive?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class UserORM:
    def __init__(self, id, name, password):
        self.id = id
        self.name = name
        self.password = password

class UserResponse(BaseModel):
    id: int
    name: str

    class Config:
        orm_mode = True

@app.get('/user', response_model=UserResponse)
async def get_user():
    user = UserORM(1, 'Alice', 'secret')
    return user

A {"password": "secret"}

B {"id": 1, "name": "Alice"}

C TypeError: Object of type UserORM is not JSON serializable

D {"id": 1, "name": "Alice", "password": "secret"}

💡 Hint

Consider what orm_mode does in Pydantic models.

orm_mode allows Pydantic to read data from ORM objects by accessing attributes. The response_model filters fields to only id and name, so password is excluded.

🧠 Conceptual

expert

Which statement best describes the purpose of response_model in FastAPI?

Choose the most accurate explanation of what response_model does in a FastAPI endpoint.

A It validates and filters the data returned by the endpoint to match the declared model before sending to the client.

B It automatically converts the request body into the declared model type.

C It defines the database schema for storing the response data.

D It disables validation and returns raw data from the endpoint.

💡 Hint

Think about what happens to the data after the endpoint returns it.

response_model tells FastAPI to validate and serialize the returned data according to the model, ensuring the client only receives the specified fields and correct types.