Request body declaration in FastAPI - Step-by-Step Execution

Concept Flow - Request body declaration

Client sends HTTP POST request

↓

FastAPI reads request body

↓

Parse JSON into Pydantic model

↓

Validate data fields

↓

Pass data to endpoint

↓

Process & respond

↓

Client receives response

This flow shows how FastAPI reads and validates the request body using a Pydantic model, then either processes valid data or returns an error.

Execution Sample

FastAPI

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}

Defines a POST endpoint that expects a JSON body matching the Item model, then returns the parsed data.

Execution Table

Step	Action	Input Data	Validation Result	Endpoint Behavior	Response
1	Receive POST /items/ with JSON body	{"name": "Book", "price": 12.5}	Pending	Parse JSON to Item model	None
2	Parse JSON into Item model	{"name": "Book", "price": 12.5}	Success	Call create_item with item	None
3	Inside create_item function	Item(name='Book', price=12.5)	Valid data	Return dict with item_name and item_price	{"item_name": "Book", "item_price": 12.5}
4	Client receives response	N/A	N/A	N/A	{"item_name": "Book", "item_price": 12.5}
5	Receive POST /items/ with invalid JSON body	{"name": "Pen", "price": "cheap"}	Pending	Parse JSON to Item model	None
6	Parse JSON into Item model	{"name": "Pen", "price": "cheap"}	Fail	Return 422 Unprocessable Entity error	{"detail": [{"loc": ["body", "price"], "msg": "value is not a valid float", "type": "type_error.float"}]}
7	Client receives error response	N/A	N/A	N/A	{"detail": [{"loc": ["body", "price"], "msg": "value is not a valid float", "type": "type_error.float"}]}

💡 Execution stops after sending response to client, either success or validation error.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
item	None	Item(name='Book', price=12.5)	Item(name='Book', price=12.5)	Returned in response dict
request_body	None	{"name": "Book", "price": 12.5}	N/A	N/A

Key Moments - 2 Insights

Why does FastAPI use a Pydantic model for the request body?

FastAPI uses Pydantic models to automatically parse and validate the JSON body, ensuring the data matches expected types before calling the endpoint function, as shown in execution_table steps 2 and 3.

What happens if the JSON body has wrong data types?

FastAPI detects the mismatch during parsing (step 6), then returns a 422 error with details about the invalid fields, preventing the endpoint function from running.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'item' after step 2?

A None

B Item(name='Book', price=12.5)

C {"name": "Book", "price": 12.5}

D 422 error response

💡 Hint

Check the 'item' variable in variable_tracker after step 2.

At which step does FastAPI return a 422 error due to invalid data?

A Step 6

B Step 3

C Step 4

D Step 2

💡 Hint

Look for 'Fail' in Validation Result column in execution_table.

If the request body JSON misses the 'price' field, what will happen?

A The endpoint returns default price 0

B The endpoint runs with price as None

C FastAPI returns a 422 validation error

D The server crashes

💡 Hint

Refer to how FastAPI handles missing required fields in execution_table step 6.

Concept Snapshot

Request body declaration in FastAPI:
- Define a Pydantic model class with fields
- Use model as function parameter in POST endpoint
- FastAPI parses and validates JSON body automatically
- On success, endpoint receives typed model instance
- On failure, FastAPI returns 422 error with details

Full Transcript

In FastAPI, when you declare a request body, you create a Pydantic model class that defines the expected data fields and their types. When a client sends a POST request with JSON data, FastAPI reads the body and tries to convert it into an instance of that model. If the data matches the model's requirements, the endpoint function receives the model instance and can use its fields directly. If the data is invalid or missing required fields, FastAPI stops and returns a 422 error with a message explaining what is wrong. This automatic parsing and validation make it easy and safe to handle request bodies.

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