Multiple path parameters in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when sending JSON with two body parameters?

Consider this FastAPI endpoint that expects two body parameters:

from fastapi import FastAPI, Body

app = FastAPI()

@app.post("/items/")
async def create_item(name: str = Body(...), description: str = Body(...)):
    return {"name": name, "description": description}

If you send a POST request with JSON body {"name": "Book", "description": "A nice book"}, what will be the response?

FastAPI

from fastapi import FastAPI, Body

app = FastAPI()

@app.post("/items/")
async def create_item(name: str = Body(...), description: str = Body(...)):
    return {"name": name, "description": description}

A 422 Unprocessable Entity error

B {"name": "Book", "description": "A nice book"}

C {"name": "Book"}

D {"description": "A nice book"}

💡 Hint

Think about how FastAPI extracts multiple body parameters from JSON.

FastAPI can extract multiple parameters from the JSON body if each is declared with Body(...). The JSON keys must match the parameter names. Here, both name and description are required, so sending both returns them in the response.

📝 Syntax

intermediate

Which code correctly defines multiple body parameters in FastAPI?

Choose the correct FastAPI endpoint definition that accepts two required string parameters title and content from the request body.

A async def post_article(title: str = Body(...), content: str = Body(...)):

B async def post_article(title: str, content: str):

C async def post_article(body: dict): title = body['title']; content = body['content']

D async def post_article(title: str = Query(...), content: str = Query(...)):

💡 Hint

Remember that Body(...) is needed to extract parameters from the JSON body.

Option A correctly uses Body(...) to declare that title and content come from the request body. Option A misses Body, so FastAPI treats them as query parameters. Option A is invalid syntax for FastAPI parameters. Option A uses Query which extracts from URL query, not body.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error?

Given this FastAPI endpoint:

from fastapi import FastAPI, Body

app = FastAPI()

@app.post("/users/")
async def create_user(name: str = Body(...), age: int = Body(...)):
    return {"name": name, "age": age}

If you send JSON {"name": "Alice"} only, what error occurs and why?

FastAPI

from fastapi import FastAPI, Body

app = FastAPI()

@app.post("/users/")
async def create_user(name: str = Body(...), age: int = Body(...)):
    return {"name": name, "age": age}

A 400 Bad Request because 'name' is missing

B 200 OK with {'name': 'Alice', 'age': None}

C 422 Unprocessable Entity because 'age' is missing

D 500 Internal Server Error due to missing age

💡 Hint

Check which parameters are required and what happens if one is missing.

Both name and age are required body parameters (due to Body(...)). Missing age causes FastAPI to return a 422 error indicating the request body is incomplete.

❓ state_output

advanced

What is the response when mixing body and query parameters?

Consider this FastAPI endpoint:

from fastapi import FastAPI, Body, Query

app = FastAPI()

@app.post("/products/")
async def add_product(name: str = Body(...), category: str = Query(...)):
    return {"name": name, "category": category}

If you send a POST request with JSON body {"name": "Laptop"} and URL query ?category=electronics, what is the response?

FastAPI

from fastapi import FastAPI, Body, Query

app = FastAPI()

@app.post("/products/")
async def add_product(name: str = Body(...), category: str = Query(...)):
    return {"name": name, "category": category}

A {"name": "Laptop", "category": "electronics"}

B {"name": "Laptop"}

C 422 Unprocessable Entity error

D {"category": "electronics"}

💡 Hint

Recall how FastAPI separates body and query parameters.

The name parameter is extracted from the JSON body, and category is extracted from the URL query string. Both are required, so sending both correctly returns them in the response.

🧠 Conceptual

expert

Why does FastAPI require explicit Body(...) for multiple body parameters?

FastAPI allows only one parameter to be taken from the request body by default. When you want multiple parameters from the body, you must use Body(...) explicitly for each. Why is this design chosen?

A Because <code>Body(...)</code> is required to validate query parameters

B Because FastAPI does not support JSON bodies without <code>Body(...)</code> annotations

C Because Python functions cannot have more than one parameter from the body without <code>Body(...)</code>

D Because HTTP requests can only have one JSON body, so FastAPI needs explicit markers to parse multiple fields separately

💡 Hint

Think about how HTTP request bodies work and how FastAPI maps them to function parameters.

HTTP requests have a single body, usually JSON. FastAPI needs to know which parameters come from that single JSON body. By default, it expects one body parameter. To extract multiple fields separately, Body(...) tells FastAPI to look inside the JSON body for each parameter explicitly.

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