Query parameter validation in FastAPI - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when accessing the endpoint with ?q=fastapi123?

Consider this FastAPI endpoint that validates a query parameter q to be a string with a minimum length of 5 and maximum length of 10:

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/items/")
async def read_items(q: str = Query(..., min_length=5, max_length=10)):
    return {"q": q}

What will be the response when a client requests /items/?q=fastapi123?

FastAPI

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/items/")
async def read_items(q: str = Query(..., min_length=5, max_length=10)):
    return {"q": q}

A 422 Unprocessable Entity error due to length exceeding max_length

B 500 Internal Server Error

C {"q": "fastapi"}

D {"q": "fastapi123"}

💡 Hint

Check the length of the string fastapi123 and compare it with the min and max length constraints.

The string fastapi123 has 10 characters, which is within the allowed range of 5 to 10 characters. So the endpoint returns the query parameter as JSON.

📝 Syntax

intermediate

Which option correctly validates an optional integer query parameter with a default of 10 and a range 1 to 100?

Choose the correct FastAPI query parameter declaration for an optional integer count with default 10, minimum 1, and maximum 100.

A count: int = Query(default=10, min_length=1, max_length=100)

B count: int = Query(10, ge=1, le=100)

C count: int = Query(10, min=1, max=100)

D count: Optional[int] = Query(default=10, min=1, max=100)

💡 Hint

Remember that ge and le are used for numeric bounds, and min_length and max_length are for strings.

Option B correctly uses ge and le for numeric bounds and sets default to 10. Option B uses wrong parameter names and Optional without import. Options A and D misuse string length parameters.

❓ state_output

advanced

What is the response when calling /search/?tags=python&tags=fastapi&tags=api?

Given this FastAPI endpoint:

from fastapi import FastAPI, Query
from typing import List

app = FastAPI()

@app.get("/search/")
async def search(tags: List[str] = Query([])):
    return {"tags": tags}

What will be the JSON response when the client calls /search/?tags=python&tags=fastapi&tags=api?

FastAPI

from fastapi import FastAPI, Query
from typing import List

app = FastAPI()

@app.get("/search/")
async def search(tags: List[str] = Query([])):
    return {"tags": tags}

A {"tags": ["python", "fastapi", "api"]}

B {"tags": "python,fastapi,api"}

C 422 Unprocessable Entity error

D {"tags": ["python"]}

💡 Hint

Think about how FastAPI handles multiple query parameters with the same name when using a List type.

FastAPI collects all query parameters with the same name into a list when the type is List[str]. So the response contains all three tags as a list.

🔧 Debug

advanced

Why does this FastAPI endpoint raise a validation error when called with ?age=twenty?

Examine this FastAPI endpoint:

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/users/")
async def get_user(age: int = Query(..., ge=0, le=120)):
    return {"age": age}

What is the reason for a 422 validation error when the client calls /users/?age=twenty?

FastAPI

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/users/")
async def get_user(age: int = Query(..., ge=0, le=120)):
    return {"age": age}

A The string 'twenty' cannot be converted to an integer, causing a validation error.

B The age value is below the minimum allowed (0).

C The age value exceeds the maximum allowed (120).

D The Query parameter is missing a default value.

💡 Hint

Consider the data type expected and the actual input value.

The query parameter expects an integer. The string 'twenty' cannot be converted to int, so FastAPI returns a 422 validation error before checking range constraints.

🧠 Conceptual

expert

Which option best describes how FastAPI validates query parameters with Pydantic constraints?

FastAPI uses Pydantic models and field constraints to validate query parameters. Which statement correctly explains this process?

A FastAPI validates query parameters only after the endpoint function runs, raising errors inside the function.

B FastAPI only checks the type of query parameters but ignores any additional constraints like min_length or ge.

C FastAPI converts query parameters to the declared type, then applies Pydantic validators and constraints, returning errors if validation fails.

D FastAPI requires manual validation code inside the endpoint to enforce constraints on query parameters.

💡 Hint

Think about when and how FastAPI applies validation rules declared with Query and Pydantic.

FastAPI uses Pydantic to parse and validate query parameters before calling the endpoint. It converts types and applies constraints like min_length, ge, le, etc. If validation fails, it returns a 422 error automatically.