Path parameters in FastAPI - Step-by-Step Execution

Concept Flow - Path parameters

Client sends request with URL

↓

FastAPI matches URL path

↓

Extract path parameter value

↓

Pass parameter to function

↓

Function processes parameter

↓

Return response with parameter data

FastAPI takes the part of the URL defined as a path parameter, passes it to your function, and uses it to create a response.

Execution Sample

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

This code defines a path parameter 'item_id' that FastAPI extracts from the URL and sends to the function.

Execution Table

Step	Request URL	Path Parameter Extracted	Function Parameter	Response
1	/items/5	item_id = 5	item_id = 5	{"item_id": 5}
2	/items/42	item_id = 42	item_id = 42	{"item_id": 42}
3	/items/abc	item_id = 'abc'	Error: invalid int	422 Unprocessable Entity

💡 Execution stops when the request URL does not match the path pattern or parameter type is invalid.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3
item_id	None	5	42	Error (invalid int)

Key Moments - 2 Insights

Why does the request to /items/abc cause an error?

Because the path parameter 'item_id' is declared as int, FastAPI tries to convert 'abc' to int and fails, causing a 422 error as shown in execution_table step 3.

How does FastAPI know which part of the URL is the path parameter?

FastAPI uses the curly braces {} in the route path to identify path parameters, as shown in the code sample and execution_table where /items/{item_id} extracts the value after /items/.

Visual Quiz - 3 Questions

Look at the execution_table, what is the response when the request URL is /items/5?

A {"item_id": 5}

B {"item_id": "5"}

C 422 Unprocessable Entity

D 404 Not Found

💡 Hint

Check execution_table row 1 under Response column.

At which step does FastAPI return an error due to invalid path parameter type?

A Step 2

B Step 3

C Step 1

D No error occurs

💡 Hint

Look at execution_table row 3 showing 'Error: invalid int' and 422 response.

If the path parameter type is changed from int to str, how would the response for /items/abc change?

A It would return 404 Not Found

B It would still return 422 error

C It would return {"item_id": "abc"} without error

D It would crash the server

💡 Hint

Refer to variable_tracker and key_moments about type conversion and errors.

Concept Snapshot

Path parameters in FastAPI are parts of the URL path wrapped in {}.
They are extracted from the URL and passed as arguments to your function.
You must declare the parameter type (e.g., int, str) for validation.
If the URL part does not match the type, FastAPI returns a 422 error.
Use path parameters to create dynamic URLs easily.

Full Transcript

In FastAPI, path parameters let you capture parts of the URL and use them in your code. When a client sends a request like /items/5, FastAPI sees the {item_id} in the route and extracts '5' as the item_id parameter. It converts it to the declared type, here int, and passes it to the function. The function then returns a response using that value. If the client sends a value that cannot convert to int, like 'abc', FastAPI returns a 422 error. This process helps create dynamic and flexible web APIs.

Practice

1. What is the purpose of path parameters in FastAPI?

easy

A. To send data only in the request body

B. To define static routes without variables

C. To capture values directly from the URL path

D. To handle only query string parameters

Solution

1. Step 1: Understand what path parameters do

   Path parameters allow the API to accept dynamic values from the URL path itself, making routes flexible.

2. Step 2: Compare with other data sources

   Unlike query parameters or request bodies, path parameters are part of the URL path, not optional or in the body.

3. Final Answer:

   To capture values directly from the URL path -> Option C

4. Quick Check:

   Path parameters = URL path values [OK]

Hint: Path parameters are always inside curly braces {} in the URL [OK]

Common Mistakes:

• Confusing path parameters with query parameters
• Thinking path parameters come from request body
• Assuming path parameters are optional by default

2. Which of the following is the correct way to declare a path parameter named item_id in FastAPI?

easy

A. @app.get("/items/:item_id")

B. @app.get("/items/item_id")

C. @app.get("/items/<item_id>")

D. @app.get("/items/{item_id}")

Solution

1. Step 1: Recall FastAPI path parameter syntax

   FastAPI uses curly braces {} to declare path parameters inside route strings.

2. Step 2: Identify the correct syntax

   Only @app.get("/items/{item_id}") uses curly braces correctly: "/items/{item_id}".

3. Final Answer:

   @app.get("/items/{item_id}") -> Option D

4. Quick Check:

   Curly braces {} = path parameters [OK]

Hint: Use curly braces {} around parameter names in route paths [OK]

Common Mistakes:

• Using quotes or angle brackets instead of curly braces
• Forgetting to wrap parameter name in braces
• Using colon syntax like other frameworks

3. Given this FastAPI code snippet, what will be the output when accessing /users/42?

from fastapi import FastAPI
app = FastAPI()

@app.get("/users/{user_id}")
async def read_user(user_id: int):
    return {"user_id": user_id}

medium

A. {"user_id": 42}

B. TypeError because user_id is not a string

C. 404 Not Found error

D. {"user_id": "42"}

Solution

1. Step 1: Understand parameter type conversion

   The path parameter user_id is declared as int, so FastAPI converts the string "42" from the URL to integer 42.

2. Step 2: Check the returned JSON

   The function returns a dictionary with key "user_id" and value 42 as an integer, which FastAPI converts to JSON.

3. Final Answer:

   {"user_id": 42} -> Option A

4. Quick Check:

   Path param type int converts "42" to 42 [OK]

Hint: Check parameter type hints to know output data type [OK]

Common Mistakes:

• Assuming path parameters are always strings
• Expecting a 404 error without reason
• Confusing JSON string with Python dict

4. What is wrong with this FastAPI path parameter code?

from fastapi import FastAPI
app = FastAPI()

@app.get("/products/{product_id}")
async def get_product(product_id):
    return {"product": product_id}

medium

A. Function must be synchronous, not async

B. Missing type annotation for product_id

C. Incorrect route path syntax

D. Return statement must be a string, not dict

Solution

1. Step 1: Check function parameter declaration

   The parameter product_id lacks a type hint, so FastAPI treats it as a string by default but it's best practice to specify type.

2. Step 2: Identify the issue

   While the code runs, missing type annotation can cause unexpected behavior or lack of validation.

3. Final Answer:

   Missing type annotation for product_id -> Option B

4. Quick Check:

   Always add type hints for path parameters [OK]

Hint: Always add type hints to path parameters for validation [OK]

Common Mistakes:

• Ignoring type hints thinking they are optional
• Confusing async with sync function requirements
• Thinking route path syntax is wrong when it is correct

5. You want to create a FastAPI route that accepts two path parameters: category (string) and item_id (integer). Which of the following is the correct way to define this route and function?

hard

A. @app.get("/items/{category}/{item_id}")
async def read_item(category: str, item_id: int):
return {"category": category, "item_id": item_id}

B. @app.get("/items/{category}/{item_id}")
async def read_item(item_id: int, category: str):
return {"category": category, "item_id": item_id}

C. @app.get("/items/{category}/{item_id}")
async def read_item(category, item_id):
return {"category": category, "item_id": item_id}

D. @app.get("/items/{category}/{item_id}")
def read_item(category: str, item_id: int):
return {"category": category, "item_id": item_id}

Solution

1. Step 1: Match path parameters with function parameters

   The route declares two path parameters in order: category then item_id. The function parameters must match this order and names.

2. Step 2: Check type annotations and async usage

   @app.get("/items/{category}/{item_id}") async def read_item(category: str, item_id: int): return {"category": category, "item_id": item_id} correctly uses type hints (str and int) and async function, which is recommended in FastAPI.

3. Final Answer:

   @app.get("/items/{category}/{item_id}") async def read_item(category: str, item_id: int): return {"category": category, "item_id": item_id} -> Option A

4. Quick Check:

   Order and types must match route parameters [OK]

Hint: Order and names of parameters must match route path [OK]

Common Mistakes:

• Swapping parameter order in function
• Omitting type hints for path parameters
• Using sync function without reason