Request body declaration in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when sending a POST request with JSON {"name": "Alice", "age": 30}?

Consider this FastAPI endpoint that declares a request body using a Pydantic model. What will the response be when the client sends the JSON {"name": "Alice", "age": 30}?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

@app.post("/user")
async def create_user(user: User):
    return {"message": f"User {user.name} is {user.age} years old."}

A {"message": "User is created."}

B {"message": "User Alice is 30 years old."}

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

D 422 Unprocessable Entity error

💡 Hint

Look at how the endpoint returns a message using the user data from the request body.

The endpoint receives a User model instance from the request body and returns a message string using the name and age fields. So the output JSON contains the message with the values inserted.

📝 Syntax

intermediate

Which option correctly declares a request body parameter in FastAPI?

You want to declare a request body parameter named 'item' of type 'Item' in a FastAPI POST endpoint. Which code snippet is syntactically correct?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    id: int
    description: str

@app.post("/items")
async def create_item(???):
    return item

A item: Item

B item = Body(Item)

C item: Body(Item)

D item: Item = Body(...)

💡 Hint

Pydantic models are automatically treated as request body parameters when used as type annotations.

In FastAPI, declaring a function parameter with a Pydantic model type annotation (e.g., item: Item) automatically expects the data in the request body and validates it as Item.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error when sending {"id": "abc", "description": "Test"}?

Given the following code, why does sending {"id": "abc", "description": "Test"} in the request body cause a validation error?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    id: int
    description: str

@app.post("/items")
async def create_item(item: Item):
    return item

A Because 'id' is declared as int but the input provides a string 'abc', causing a type validation error.

B Because 'description' is missing from the request body.

C Because the endpoint is missing the Body import from fastapi.

D Because the endpoint does not return a JSON response.

💡 Hint

Check the type of the 'id' field in the Pydantic model and the input value.

Pydantic validates the input types strictly. The 'id' field expects an integer, but the input provides a string 'abc', so validation fails and FastAPI returns a 422 error.

❓ state_output

advanced

What is the response when sending an empty JSON {} to this endpoint?

Given this FastAPI endpoint, what will be the response if the client sends an empty JSON object {} in the request body?

FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/products")
async def create_product(product: Product):
    return {"product_name": product.name, "product_price": product.price}

A {"product_name": "", "product_price": 0.0}

B {"product_name": null, "product_price": null}

C 422 Unprocessable Entity error due to missing required fields

D 200 OK with empty JSON response {}

💡 Hint

Pydantic requires all fields without defaults to be present in the request body.

Since 'name' and 'price' are required fields without default values, sending an empty JSON causes validation to fail and FastAPI returns a 422 error.

🧠 Conceptual

expert

Which statement about FastAPI request body declaration is TRUE?

Select the correct statement about how FastAPI handles request body declarations with Pydantic models.

A FastAPI does not support nested Pydantic models in request bodies.

B You must manually parse JSON request bodies using json.loads before passing to Pydantic models.

C Request body parameters must always be declared with Body(...) even if using Pydantic models.

D FastAPI automatically parses and validates JSON request bodies into Pydantic models when declared as function parameters.

💡 Hint

Think about how FastAPI integrates with Pydantic for request validation.

FastAPI automatically reads the JSON request body, converts it into the declared Pydantic model, and validates it. You do not need to manually parse JSON or always use Body(...). Nested models are supported.