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.