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.

Practice

1. What is the main purpose of declaring a request body in FastAPI using a Pydantic model?

easy

A. To define the URL path for the API endpoint

B. To tell FastAPI what data structure to expect and validate from the client

C. To specify the HTTP method like GET or POST

D. To set the response status code

Solution

1. Step 1: Understand request body role

   The request body contains data sent by the client to the server, usually in POST or PUT requests.

2. Step 2: Role of Pydantic model in FastAPI

   Using a Pydantic model tells FastAPI the expected data shape and automatically validates it.

3. Final Answer:

   To tell FastAPI what data structure to expect and validate from the client -> Option B

4. Quick Check:

   Request body declaration = Data validation [OK]

Hint: Request body = data shape + validation [OK]

Common Mistakes:

• Confusing request body with URL path
• Thinking request body sets HTTP method
• Assuming request body controls response code

2. Which of the following is the correct way to declare a request body parameter in a FastAPI endpoint?

easy

A. def create_item(item: dict):

B. def create_item(item: BaseModel):

C. def create_item(item: Item):

D. def create_item(item: str):

Solution

1. Step 1: Recognize Pydantic model usage

   FastAPI expects a Pydantic model class (like Item) to declare request body parameters.

2. Step 2: Check each option

   def create_item(item: dict): uses dict which works but is not recommended; def create_item(item: BaseModel): uses BaseModel directly which is abstract; def create_item(item: Item): uses a user-defined model Item which is correct; def create_item(item: str): uses str which is not a model.

3. Final Answer:

   def create_item(item: Item): -> Option C

4. Quick Check:

   Use Pydantic model class for request body [OK]

Hint: Use your Pydantic model class as parameter type [OK]

Common Mistakes:

• Using dict instead of a Pydantic model
• Using BaseModel directly instead of subclass
• Using primitive types like str for complex data

3. Given this FastAPI code snippet, what will be the output if the client sends JSON {"name": "apple", "price": 5}?

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

medium

A. {"item_name": "apple", "item_price": "5"}

B. 500 Internal Server Error

C. ValidationError because price is int, not float

D. {"item_name": "apple", "item_price": 5.0}

Solution

1. Step 1: Understand Pydantic type conversion

   Pydantic automatically converts compatible types, so int 5 converts to float 5.0.

2. Step 2: Check returned dictionary

   The function returns a dict with keys "item_name" and "item_price" using the values from the item object.

3. Final Answer:

   {"item_name": "apple", "item_price": 5.0} -> Option D

4. Quick Check:

   Int converts to float automatically in Pydantic [OK]

Hint: Pydantic converts int to float automatically [OK]

Common Mistakes:

• Thinking int and float types cause validation error
• Expecting string instead of float for price
• Assuming server error on type mismatch

4. Identify the error in this FastAPI endpoint declaration:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/users/")
def create_user(user: User = None):
    return {"username": user.username, "age": user.age}

medium

A. Request body parameter cannot have a default value None

B. Missing async keyword in endpoint function

C. User class must inherit from object, not BaseModel

D. Return statement must be inside an async function

Solution

1. Step 1: Check request body parameter declaration

   In FastAPI, request body parameters cannot have a default value of None because the body is required by default.

2. Step 2: Review other options

   Async is optional for FastAPI endpoints; BaseModel inheritance is correct; return works in sync functions.

3. Final Answer:

   Request body parameter cannot have a default value None -> Option A

4. Quick Check:

   Request body params must not default to None [OK]

Hint: Request body params must be required unless explicitly optional [OK]

Common Mistakes:

• Adding default None to request body param
• Thinking async is mandatory
• Misunderstanding BaseModel inheritance

5. You want to declare a request body in FastAPI that accepts an optional field description which can be missing or null. How should you declare the Pydantic model to handle this correctly?

hard

A. from pydantic import BaseModel
from typing import Optional

class Item(BaseModel):
name: str
description: Optional[str] = None

B. from pydantic import BaseModel

class Item(BaseModel):
name: str
description: str

C. from pydantic import BaseModel
from typing import Union

class Item(BaseModel):
name: str
description: Union[str, None] = None

D. from pydantic import BaseModel

class Item(BaseModel):
name: str
description: None

Solution

1. Step 1: Understand optional fields in Pydantic

   To allow a field to be optional or null, use Optional[type] with a default value None.

2. Step 2: Analyze each option

   from pydantic import BaseModel from typing import Optional class Item(BaseModel): name: str description: Optional[str] = None correctly uses Optional[str] with default None; from pydantic import BaseModel class Item(BaseModel): name: str description: str requires description always; from pydantic import BaseModel from typing import Union class Item(BaseModel): name: str description: Union[str, None] = None uses Union[str, None] with default None; from pydantic import BaseModel class Item(BaseModel): name: str description: None sets description to None type which is invalid.

3. Final Answer:

   Use Optional[str] with default None for optional nullable field -> Option A

4. Quick Check:

   Optional field = Optional[type] + default None [OK]

Hint: Use Optional[type] and default None for optional fields [OK]

Common Mistakes:

• Forgetting to set default None for optional fields
• Using plain type without Optional for nullable fields
• Assigning None as a type instead of a value