Path parameter types and validation in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when accessing a path with a typed parameter?

Consider this FastAPI code snippet:

from fastapi import FastAPI
app = FastAPI()

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

What will be the JSON response when you access /items/5?

FastAPI

from fastapi import FastAPI
app = FastAPI()

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

A {"item_id": "5"}

B 404 Not Found error

C {"item_id": 10}

D 500 Internal Server Error

💡 Hint

Remember that FastAPI converts path parameters to the declared type automatically.

The path parameter item_id is declared as int. FastAPI converts the string from the URL to an integer. Then the function returns the doubled value, so 5 * 2 = 10.

📝 Syntax

intermediate

Which path parameter declaration causes a validation error for non-integers?

Given these FastAPI path operations, which one will reject a non-integer path parameter like /users/abc with a 422 error?

A

@app.get('/users/{user_id}')
async def get_user(user_id: float):
    return {"user_id": user_id}

B

@app.get('/users/{user_id}')
async def get_user(user_id: str):
    return {"user_id": user_id}

C

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

D

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

💡 Hint

FastAPI validates path parameters based on their declared type annotations.

Only when the path parameter is declared as int or float will FastAPI validate and reject invalid strings with a 422 error. Declaring as str or no type means no validation error for non-integers.

🔧 Debug

advanced

Why does this FastAPI path parameter validation still work despite the default value?

Look at this code:

from fastapi import FastAPI
app = FastAPI()

@app.get('/products/{product_id}')
async def get_product(product_id: int = 0):
    return {"product_id": product_id}

When accessing /products/abc, the API returns a 422 validation error (not {"product_id": 0}). Why?

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get('/products/{product_id}')
async def get_product(product_id: int = 0):
    return {"product_id": product_id}

A Because default values in path parameters do not disable type validation; the path segment is still validated as int.

B Because FastAPI automatically converts 'abc' to 0 when default is set.

C Because the function is missing a type annotation for product_id.

D Because the route path is incorrect and does not match the request.

💡 Hint

Default values do not make path parameters optional or disable their type validation in FastAPI.

Path parameters are always required and validated based on their type annotation, even with a default value set. FastAPI attempts to convert the path segment ('abc') to int, which fails, resulting in a 422 error. The default is not used.

❓ state_output

advanced

What is the response when using a constrained path parameter with validation?

Given this FastAPI code:

from fastapi import FastAPI, Path
app = FastAPI()

@app.get('/orders/{order_id}')
async def read_order(order_id: int = Path(..., gt=100, lt=200)):
    return {"order_id": order_id}

What happens when you access /orders/150 and /orders/99 respectively?

FastAPI

from fastapi import FastAPI, Path
app = FastAPI()

@app.get('/orders/{order_id}')
async def read_order(order_id: int = Path(..., gt=100, lt=200)):
    return {"order_id": order_id}

A Both /orders/150 and /orders/99 return {"order_id": <value>} without validation.

B Accessing /orders/150 returns 422 error; /orders/99 returns {"order_id": 99}.

C Both /orders/150 and /orders/99 return 422 validation errors.

D Accessing /orders/150 returns {"order_id": 150}; /orders/99 returns 422 validation error.

💡 Hint

Path parameters can have validation constraints like greater than (gt) and less than (lt).

The Path function enforces that order_id must be greater than 100 and less than 200. 150 meets this, so it returns normally. 99 fails the gt=100 check, so FastAPI returns a 422 error.

🧠 Conceptual

expert

How does FastAPI handle path parameter type conversion and validation internally?

Which statement best describes FastAPI's process for path parameter type conversion and validation?

A FastAPI converts path parameters to strings and leaves validation to the endpoint function code.

B FastAPI uses Python type hints to convert path parameters and Pydantic to validate constraints before calling the endpoint function.

C FastAPI only validates query parameters, not path parameters, which are always strings.

D FastAPI requires manual conversion and validation of path parameters inside the endpoint function.

💡 Hint

Think about how FastAPI uses Python typing and Pydantic models.

FastAPI reads the type hints on path parameters and uses Pydantic internally to convert and validate the values before passing them to the function. This automatic process ensures type safety and validation.

Practice

1. What is the main purpose of specifying a type for a path parameter in FastAPI?

easy

A. To disable validation for that parameter

B. To make the parameter optional in the URL

C. To automatically generate HTML forms

D. To ensure the parameter value matches the expected data type from the URL

Solution

1. Step 1: Understand path parameters in FastAPI

   Path parameters extract values from the URL and can be typed to ensure correct data types.

2. Step 2: Role of typing in path parameters

   Typing enforces that the value received matches the expected type, preventing errors and invalid data.

3. Final Answer:

   To ensure the parameter value matches the expected data type from the URL -> Option D

4. Quick Check:

   Path parameter typing = type safety [OK]

Hint: Path parameter types check URL values match expected type [OK]

Common Mistakes:

• Thinking typing makes parameters optional
• Believing typing disables validation
• Confusing path parameters with query parameters

2. Which of the following is the correct way to declare an integer path parameter with a minimum value of 1 in FastAPI?

easy

A. def read_item(item_id: int = Path(min=1)):

B. def read_item(item_id: int = Path(minimum=1)):

C. def read_item(item_id: int = Path(ge=1)):

D. def read_item(item_id: int = Path(min_value=1)):

Solution

1. Step 1: Recall FastAPI Path parameter validation syntax

   FastAPI uses Path() with keyword arguments like ge (greater or equal) for minimum values.

2. Step 2: Identify correct keyword for minimum value

   The correct keyword is ge=1, not min, minimum, or min_value.

3. Final Answer:

   def read_item(item_id: int = Path(ge=1)): -> Option C

4. Quick Check:

   Minimum value keyword = ge [OK]

Hint: Use ge= for minimum value in Path() [OK]

Common Mistakes:

• Using min or minimum instead of ge
• Using min_value which is invalid
• Omitting Path() and just typing int

3. Given this FastAPI path operation:

from fastapi import FastAPI, Path
app = FastAPI()

@app.get('/users/{user_id}')
async def get_user(user_id: int = Path(ge=1, le=10)):
    return {"user_id": user_id}

What will be the response if the client requests /users/15?

medium

A. Returns 422 Unprocessable Entity error

B. Returns {"user_id": "15"} as string

C. Returns 404 Not Found error

D. Returns {"user_id": 15}

Solution

1. Step 1: Understand validation constraints

   The path parameter user_id must be an integer between 1 and 10 inclusive.

2. Step 2: Analyze the request value

   The client requests /users/15, which is outside the allowed range (greater than 10).

3. Step 3: FastAPI validation behavior

   FastAPI automatically returns a 422 error if validation fails for path parameters.

4. Final Answer:

   Returns 422 Unprocessable Entity error -> Option A

5. Quick Check:

   Invalid path param value = 422 error [OK]

Hint: Out-of-range path params cause 422 error [OK]

Common Mistakes:

• Expecting 404 instead of 422
• Assuming FastAPI converts invalid values silently
• Thinking invalid values return as strings

4. Identify the error in this FastAPI path parameter declaration:

from fastapi import FastAPI, Path
app = FastAPI()

@app.get('/items/{item_id}')
async def read_item(item_id: str = Path(gt=0)):
    return {"item_id": item_id}

medium

A. Using gt=0 with a string type causes a validation error

B. Missing type annotation for item_id

C. Path() cannot be used with string parameters

D. The route path should not include curly braces

Solution

1. Step 1: Check parameter type and validation

   The parameter item_id is typed as str but uses gt=0 which means greater than 0, a numeric constraint.

2. Step 2: Understand validation mismatch

   Numeric validations like gt apply only to numbers, not strings, causing a validation error.

3. Final Answer:

   Using gt=0 with a string type causes a validation error -> Option A

4. Quick Check:

   Numeric validation on string param = error [OK]

Hint: Numeric validators only work with numeric types [OK]

Common Mistakes:

• Applying numeric validation to strings
• Forgetting to annotate type
• Misunderstanding route path syntax

5. You want to create a FastAPI endpoint that accepts a path parameter product_id which must be an integer between 100 and 999 inclusive. If the value is invalid, FastAPI should reject the request automatically. Which of the following is the best way to declare this parameter?

hard

A. def get_product(product_id: int = Path(min=100, max=999)):

B. def get_product(product_id: int = Path(ge=100, le=999)):

C. def get_product(product_id: int = Path(gt=100, lt=999)):

D. def get_product(product_id: int = Path(minimum=100, maximum=999)):

Solution

1. Step 1: Recall correct validation keywords in Path()

   FastAPI uses ge (greater or equal) and le (less or equal) for inclusive range validation.

2. Step 2: Analyze each option's keywords

   def get_product(product_id: int = Path(ge=100, le=999)): uses ge=100 and le=999 which matches the requirement exactly. The remaining options use invalid keywords or exclusive bounds. def get_product(product_id: int = Path(gt=100, lt=999)): uses exclusive bounds which exclude 100 and 999.

3. Final Answer:

   def get_product(product_id: int = Path(ge=100, le=999)): -> Option B

4. Quick Check:

   Inclusive range validation = ge and le [OK]

Hint: Use ge and le for inclusive min and max in Path() [OK]

Common Mistakes:

• Using min/max instead of ge/le
• Using gt/lt for inclusive bounds
• Using invalid keyword names