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.