Multiple path parameters in FastAPI - Step-by-Step Execution

Concept Flow - Body with multiple parameters

Client sends POST request

↓

FastAPI reads request body

↓

Parse first parameter from body

↓

Parse second parameter from body

↓

Pass parameters to function

↓

Function processes parameters

↓

Return response with processed data

FastAPI reads the JSON body, extracts multiple parameters, passes them to the function, and returns a response.

Execution Sample

FastAPI

from fastapi import FastAPI, Body
from pydantic import BaseModel

app = FastAPI()

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

@app.post("/items/")
async def create_item(item: Item = Body(...), quantity: int = Body(...)):
    return {"item_name": item.name, "total_price": item.price * quantity}

This code defines a POST endpoint that accepts an item object and a quantity from the request body and returns the total price.

Execution Table

Step	Action	Input Data	Parameter Parsed	Function Output
1	Receive POST request	{"name": "Book", "price": 12.5, "quantity": 3}	None yet	None yet
2	Parse 'item' parameter	{"name": "Book", "price": 12.5}	Item(name='Book', price=12.5)	None yet
3	Parse 'quantity' parameter	3	quantity=3	None yet
4	Call create_item function	item=Item(name='Book', price=12.5), quantity=3	Both parameters ready	Return {'item_name': 'Book', 'total_price': 37.5}
5	Send response	Return data	N/A	{"item_name": "Book", "total_price": 37.5}

💡 All parameters parsed and function executed, response sent to client.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
item	None	Item(name='Book', price=12.5)	Item(name='Book', price=12.5)	Item(name='Book', price=12.5)	Item(name='Book', price=12.5)
quantity	None	None	3	3	3
output	None	None	None	{"item_name": "Book", "total_price": 37.5}	{"item_name": "Book", "total_price": 37.5}

Key Moments - 3 Insights

Why do we need to use a Pydantic model for the 'item' parameter?

Because FastAPI uses Pydantic models to validate and parse complex JSON objects from the request body, as shown in step 2 of the execution_table.

How does FastAPI know which parameters come from the body?

FastAPI infers that Pydantic models come from the body automatically, and simple types like 'int' can also come from the body if declared as parameters with Body(), as seen in steps 2 and 3.

Can we have multiple parameters from the body without using a Pydantic model?

No, FastAPI expects only one body parameter by default. To have multiple, you wrap them in a Pydantic model or use special techniques like declaring parameters with Body(). Here, 'quantity' is a simple parameter but must be declared properly.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'quantity' after Step 3?

A 3

B None

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

D 0

💡 Hint

Check the 'quantity' column in variable_tracker after Step 3.

At which step does the function 'create_item' return the output?

A Step 2

B Step 4

C Step 5

D Step 3

💡 Hint

Look at the 'Function Output' column in execution_table.

If the 'quantity' parameter was missing in the request, what would happen?

A The function would receive quantity=0 automatically.

B The function would receive quantity=None without error.

C FastAPI would raise a validation error before calling the function.

D The response would be empty.

💡 Hint

FastAPI requires all declared body parameters unless default values are set.

Concept Snapshot

FastAPI Body with multiple parameters:
- Use Pydantic models for complex JSON body parts.
- Declare multiple parameters in function signature with Body().
- FastAPI parses each from request body.
- Function receives parsed parameters.
- Returns response using processed data.

Full Transcript

This visual execution shows how FastAPI handles a POST request with multiple parameters in the body. The client sends JSON including an item object and a quantity. FastAPI first parses the 'item' parameter using the Pydantic model, then parses the 'quantity' integer. After both are ready, FastAPI calls the endpoint function with these parameters. The function calculates the total price and returns a JSON response. Variables 'item' and 'quantity' change from None to their parsed values step by step. Key points include the need for Pydantic models for complex data and how FastAPI infers body parameters. The quiz questions check understanding of parameter parsing and function execution steps.

Practice

1. In FastAPI, how do you accept multiple JSON body parameters in a single endpoint function?

easy

A. Use query parameters instead of body parameters.

B. Use a single parameter with a list of dictionaries.

C. Define multiple function parameters each with a Pydantic model type.

D. Combine all parameters into a single string and parse manually.

Solution

1. Step 1: Understand FastAPI body parameter handling

   FastAPI reads JSON body parameters by matching function argument names and types, typically Pydantic models.

2. Step 2: Accept multiple parameters

   By defining multiple function parameters with Pydantic models, FastAPI expects each as a separate JSON object in the request body.

3. Final Answer:

   Define multiple function parameters each with a Pydantic model type. -> Option C

4. Quick Check:

   Multiple body parameters = multiple Pydantic model arguments [OK]

Hint: Use separate Pydantic models as function parameters for multiple bodies [OK]

Common Mistakes:

• Trying to pass multiple JSON objects in one body without models
• Using query parameters instead of body for complex data
• Combining all data into one string and parsing manually

2. Which of the following is the correct syntax to declare two body parameters user and item in a FastAPI endpoint?

easy

A. async def endpoint(user: User = Body(), item: Item = Body()):

B. async def endpoint(user: User, item: Item = Query()):

C. async def endpoint(user: User, item: Item):

D. async def endpoint(user: User = Query(), item: Item = Body()):

Solution

1. Step 1: Understand parameter declaration for multiple bodies

   FastAPI requires explicit use of Body() for multiple body parameters to distinguish them.

2. Step 2: Check each option

   async def endpoint(user: User = Body(), item: Item = Body()): correctly uses = Body() for both parameters. async def endpoint(user: User, item: Item): misses Body(), so FastAPI treats only the first as body. Options B and D incorrectly mix Query() and Body().

3. Final Answer:

   async def endpoint(user: User = Body(), item: Item = Body()): -> Option A

4. Quick Check:

   Multiple bodies require = Body() [OK]

Hint: Use = Body() for each body parameter to avoid errors [OK]

Common Mistakes:

• Omitting = Body() for multiple body parameters
• Mixing query and body decorators incorrectly
• Using default values without Body()

3. Given the following FastAPI endpoint, what will be the response if the client sends JSON body with {"user": {"name": "Alice"}, "item": {"id": 5}}?

from fastapi import FastAPI, Body
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str

class Item(BaseModel):
    id: int

@app.post("/create")
async def create(user: User = Body(), item: Item = Body()):
    return {"user_name": user.name, "item_id": item.id}

medium

A. 500 Internal Server Error

B. 422 Unprocessable Entity error

C. {"user": {"name": "Alice"}, "item": {"id": 5}}

D. {"user_name": "Alice", "item_id": 5}

Solution

1. Step 1: Understand parameter parsing

   FastAPI matches the JSON keys "user" and "item" to the parameters user and item respectively, parsing each into the corresponding Pydantic model.

2. Step 2: Check the return statement

   The function returns a dictionary with keys "user_name" and "item_id" extracted from the parsed models, so the response JSON will contain these values.

3. Final Answer:

   {"user_name": "Alice", "item_id": 5} -> Option D

4. Quick Check:

   Parsed models return selected fields as response [OK]

Hint: Response keys come from return dict, not original JSON keys [OK]

Common Mistakes:

• Expecting the entire input JSON as output
• Confusing 422 error with correct parsing
• Assuming server error without code issues

4. Identify the error in this FastAPI endpoint that tries to accept two body parameters user and item:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str

class Item(BaseModel):
    id: int

@app.post("/add")
async def add(user: User, item: Item):
    return {"user": user, "item": item}

medium

A. Pydantic models cannot be used as parameters.

B. Missing = Body() for multiple body parameters causes validation error.

C. Return statement must convert models to dict before returning.

D. Endpoint must be synchronous, not async.

Solution

1. Step 1: Check parameter declarations

   When multiple body parameters are declared, each must use = Body() to tell FastAPI to parse them from the body separately.

2. Step 2: Analyze the return statement

   Returning Pydantic models directly is allowed; FastAPI serializes them automatically, so no error here.

3. Final Answer:

   Missing = Body() for multiple body parameters causes validation error. -> Option B

4. Quick Check:

   Multiple bodies require = Body() [OK]

Hint: Add = Body() for each body parameter to fix errors [OK]

Common Mistakes:

• Omitting = Body() for multiple body parameters
• Thinking Pydantic models can't be returned directly
• Confusing async with sync function requirements

5. You want to create a FastAPI endpoint that accepts two body parameters: user with fields name and age, and preferences with optional color and food. Which code correctly defines the endpoint and handles missing optional fields gracefully?

hard

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

class Preferences(BaseModel):
color: str | None = None
food: str | None = None

@app.post("/profile")
async def profile(user: User = Body(), preferences: Preferences = Body()):
return {"user": user.dict(), "preferences": preferences.dict()}

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

class Preferences(BaseModel):
color: str
food: str

@app.post("/profile")
async def profile(user: User, preferences: Preferences):
return {"user": user, "preferences": preferences}

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

@app.post("/profile")
async def profile(user: User, preferences: dict = Body()):
return {"user": user, "preferences": preferences}

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

class Preferences(BaseModel):
color: Optional[str]
food: Optional[str]

@app.post("/profile")
async def profile(user: User = Body(), preferences: Preferences = Body()):
return {"user": user.dict(), "preferences": preferences.dict()}

Solution

1. Step 1: Define optional fields correctly

   Using str | None = None sets optional fields with default None, allowing missing keys without error.

2. Step 2: Declare multiple body parameters with = Body()

   This tells FastAPI to parse both user and preferences from the JSON body separately.

3. Step 3: Return dict representations for JSON serialization

   Calling .dict() on Pydantic models converts them to plain dicts for clean JSON output.

4. Final Answer:

   Defines optional fields with `str | None = None`, uses `= Body()` for multiple parameters, and returns `.dict()` representations. -> Option A

5. Quick Check:

   Optional fields + multiple bodies + dict() return = class User(BaseModel): name: str age: int class Preferences(BaseModel): color: str | None = None food: str | None = None @app.post("/profile") async def profile(user: User = Body(), preferences: Preferences = Body()): return {"user": user.dict(), "preferences": preferences.dict()} [OK]

Hint: Use field: type | None = None for optional fields [OK]

Common Mistakes:

• Not marking optional fields with default None
• Omitting = Body() for multiple parameters
• Returning Pydantic models without converting to dict