Multiple query parameters in FastAPI - Deep Dive

Overview - Multiple query parameters

What is it?

Multiple query parameters allow a web API to accept several pieces of information from the URL after the question mark. Each parameter has a name and a value, separated by an equals sign, and multiple parameters are joined by ampersands. FastAPI makes it easy to read these parameters in your code so you can use them to control what data your API returns.

Why it matters

Without multiple query parameters, APIs would be limited to receiving only one piece of information at a time, making them less flexible and harder to use. Multiple parameters let users filter, sort, or customize the data they want, improving user experience and efficiency. This is like ordering a meal with many options instead of just one fixed dish.

Where it fits

Before learning this, you should understand basic FastAPI routing and how to create simple endpoints. After mastering multiple query parameters, you can learn about request bodies, path parameters, and advanced validation to build more powerful APIs.

Mental Model

Core Idea

Multiple query parameters are named pieces of information sent in the URL that FastAPI automatically reads and passes to your function as separate variables.

Think of it like...

It's like filling out a form with several fields on a website; each field has a label and a value, and together they tell the server exactly what you want.

URL example:
https://api.example.com/items?color=red&size=medium&sort=price

FastAPI function:
┌───────────────────────────────┐
│ def get_items(color, size, sort): │
│   # use color, size, sort here  │
└───────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic query parameters

Concept: Learn how to accept a single query parameter in FastAPI.

In FastAPI, you can add a query parameter by adding a function argument without a default value or with a default. For example: from fastapi import FastAPI app = FastAPI() @app.get('/items') async def read_item(q: str = None): return {'query': q} This lets users call /items?q=somevalue and get back the value.

Result

The API returns the value of the single query parameter 'q' if provided, or None if not.

Understanding how FastAPI maps URL query parameters to function arguments is the foundation for handling multiple parameters.

2

Foundation

How query parameters appear in URLs

Concept: Learn the URL format for multiple query parameters.

Query parameters come after a question mark (?) in the URL. Each parameter is a key=value pair. Multiple parameters are joined by ampersands (&). For example: /items?color=blue&size=large Here, 'color' and 'size' are two query parameters with their values.

Result

You can pass multiple pieces of information in the URL to control API behavior.

Knowing the URL structure helps you understand how browsers and clients send multiple parameters to your API.

3

Intermediate

Accepting multiple query parameters in FastAPI

🤔Before reading on: do you think FastAPI requires special code to handle multiple query parameters or just multiple function arguments? Commit to your answer.

Concept: FastAPI lets you accept multiple query parameters by adding multiple function arguments with types and optional defaults.

Example: @app.get('/items') async def read_items(color: str = None, size: str = None): return {'color': color, 'size': size} Users can call /items?color=red&size=small and get both values back.

Result

The API returns a JSON object with both 'color' and 'size' values from the URL.

FastAPI automatically matches query parameters to function arguments by name, making it simple to handle many parameters.

4

Intermediate

Using lists for repeated query parameters

🤔Before reading on: do you think FastAPI can accept multiple values for the same query parameter as a list automatically? Commit to yes or no.

Concept: FastAPI supports receiving multiple values for the same query parameter as a list by using typing.List or list in the function signature.

Example: from typing import List @app.get('/items') async def read_items(tags: List[str] = []): return {'tags': tags} Calling /items?tags=red&tags=blue returns tags as ['red', 'blue'].

Result

The API returns a list of all values passed for the repeated query parameter.

Knowing how to accept lists lets your API handle flexible filters or multiple selections from users.

5

Intermediate

Setting default values and required parameters

🤔Before reading on: do you think a query parameter without a default is required or optional in FastAPI? Commit to your answer.

Concept: In FastAPI, query parameters without a default value are required; those with defaults are optional.

Example: @app.get('/items') async def read_items(color: str, size: str = 'medium'): return {'color': color, 'size': size} Here, 'color' must be provided, but 'size' defaults to 'medium' if missing.

Result

The API enforces required parameters and uses defaults for optional ones.

Understanding required vs optional parameters helps you design clear and user-friendly APIs.

6

Advanced

Validating and documenting query parameters

🤔Before reading on: do you think FastAPI automatically documents multiple query parameters in the API docs? Commit to yes or no.

Concept: FastAPI uses Python type hints and optional Query() to validate and document query parameters automatically.

Example: from fastapi import Query @app.get('/items') async def read_items( color: str = Query(..., min_length=3, max_length=10), size: str = Query('medium', regex='^(small|medium|large)$') ): return {'color': color, 'size': size} This enforces rules and shows descriptions in docs.

Result

The API validates inputs and generates clear interactive documentation for users.

Using Query() enhances API reliability and user experience by enforcing rules and showing helpful docs.

7

Expert

Handling complex query parameters with Pydantic models

🤔Before reading on: do you think FastAPI can parse multiple query parameters into a single Pydantic model automatically? Commit to yes or no.

Concept: FastAPI can use Pydantic models to group multiple query parameters into one object for cleaner code and validation.

Example: from pydantic import BaseModel from fastapi import Depends class ItemQuery(BaseModel): color: str size: str = 'medium' @app.get('/items') async def read_items(query: ItemQuery = Depends()): return query.dict() FastAPI maps query parameters to the model fields.

Result

The API receives multiple query parameters as one validated object, simplifying complex endpoints.

Grouping parameters into models improves code organization and scales well for large APIs.

Under the Hood

FastAPI uses Python's function signature inspection to detect parameters. When a request arrives, it parses the URL's query string into key-value pairs. It matches these keys to function argument names and converts values to the declared types using Pydantic or standard Python type conversion. For repeated parameters, it collects all values into lists. If a parameter is missing and has no default, FastAPI raises a validation error. This process happens asynchronously and efficiently inside the ASGI server.

Why designed this way?

FastAPI was designed to leverage Python's modern type hints and Pydantic validation to provide automatic, clear, and fast request parsing. This approach reduces boilerplate code and errors compared to manual parsing. Alternatives like manual parsing or using decorators were more error-prone and verbose. The design also supports automatic API documentation generation, improving developer experience.

┌───────────────┐
│ HTTP Request  │
│ URL with ?    │
│ query params  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ FastAPI Router│
│ parses query  │
│ string to dict│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Function      │
│ signature     │
│ inspection    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Parameter     │
│ matching &    │
│ type casting  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Function call │
│ with typed    │
│ arguments     │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think query parameters must always be strings and cannot be lists? Commit to yes or no.

Common Belief: Query parameters are always single strings; you cannot send multiple values for the same parameter.

Reality: FastAPI supports multiple values for the same query parameter by using list types in function arguments.

Why it matters: Believing this limits API design and prevents users from filtering or selecting multiple options easily.

Quick: Do you think query parameters without defaults are optional in FastAPI? Commit to yes or no.

Common Belief: If you don't provide a default value, the query parameter is optional and can be missing.

Reality: In FastAPI, query parameters without defaults are required; missing them causes a validation error.

Why it matters: Misunderstanding this causes unexpected errors and confusion when users omit required parameters.

Quick: Do you think FastAPI requires manual parsing of query parameters from the URL string? Commit to yes or no.

Common Belief: You must manually parse the query string to get parameters in FastAPI.

Reality: FastAPI automatically parses and converts query parameters based on function signatures and types.

Why it matters: Thinking manual parsing is needed leads to redundant code and missed benefits of FastAPI's automation.

Quick: Do you think you cannot group multiple query parameters into one object in FastAPI? Commit to yes or no.

Common Belief: Each query parameter must be a separate function argument; grouping is not possible.

Reality: FastAPI can use Pydantic models with Depends() to group multiple query parameters into one validated object.

Why it matters: Not knowing this leads to cluttered code and harder maintenance for endpoints with many parameters.

Expert Zone

1

FastAPI's automatic documentation (Swagger UI) reflects multiple query parameters and their validations without extra code, improving API usability.

2

Using Pydantic models for query parameters allows nested validation and default values, which is powerful for complex APIs but requires understanding Depends().

3

Repeated query parameters are collected in the order they appear in the URL, which can affect processing logic if order matters.

When NOT to use

If you need to send large or sensitive data, query parameters are not suitable; use request bodies instead. Also, avoid using too many query parameters as it can make URLs long and hard to manage; consider POST requests with JSON bodies for complex filters.

Production Patterns

In real APIs, multiple query parameters are used for filtering, sorting, pagination, and searching. Grouping parameters into Pydantic models is common for clean code. Validation rules ensure data quality. APIs often combine query parameters with path parameters and request bodies for flexible endpoints.

Connections

HTTP URL encoding

Builds-on

Understanding how query parameters are encoded in URLs helps grasp how special characters are safely transmitted and decoded by FastAPI.

Form data submission

Related pattern

Both query parameters and form data send key-value pairs to the server, but query parameters appear in the URL while form data is in the request body.

Database query filtering

Builds-on

Multiple query parameters often map directly to database filters, so understanding them helps design APIs that efficiently query data.

Common Pitfalls

#1 Forgetting to provide required query parameters causes errors.

Wrong approach:

@app.get('/items')
async def read_items(color: str):
return {'color': color}

# Called as /items without ?color=... parameter

Correct approach:

@app.get('/items')
async def read_items(color: str = None):
return {'color': color}

# Now color is optional

Root cause:

Assuming parameters without defaults are optional, but FastAPI treats them as required.

#2 Trying to accept multiple values for a parameter without using a list type.

Wrong approach:

@app.get('/items')
async def read_items(tags: str = None):
return {'tags': tags}

# Called as /items?tags=red&tags=blue returns only last value

Correct approach:

from typing import List

@app.get('/items')
async def read_items(tags: List[str] = []):
return {'tags': tags}

# Returns all values as list

Root cause:

Not using list types to capture repeated query parameters.

#3 Manually parsing query parameters from request instead of using function arguments.

Wrong approach:

from fastapi import Request

@app.get('/items')
async def read_items(request: Request):
q = request.query_params.get('q')
return {'q': q}

Correct approach:

@app.get('/items')
async def read_items(q: str = None):
return {'q': q}

Root cause:

Not leveraging FastAPI's automatic parsing and type conversion.

Key Takeaways

Multiple query parameters let APIs receive many pieces of information from the URL to customize responses.

FastAPI automatically matches query parameters to function arguments by name and converts types based on annotations.

You can accept repeated parameters as lists by using typing.List or list in your function signature.

Parameters without default values are required; those with defaults are optional, helping enforce API contracts.

Using Pydantic models with Depends() groups multiple query parameters into one validated object for cleaner code.

Practice

1. What is the main purpose of using multiple query parameters in a FastAPI endpoint?

easy

A. To accept several inputs from the URL to customize the response

B. To define multiple routes in one function

C. To handle only POST request data

D. To create database models automatically

Solution

1. Step 1: Understand query parameters in FastAPI

   Query parameters allow passing data in the URL after a question mark, like ?name=John.

2. Step 2: Purpose of multiple query parameters

   Using multiple query parameters lets the API accept many inputs to customize what it returns.

3. Final Answer:

   To accept several inputs from the URL to customize the response -> Option A

4. Quick Check:

   Multiple query parameters = multiple inputs [OK]

Hint: Multiple query parameters let you send many inputs in URL [OK]

Common Mistakes:

• Confusing query parameters with request body
• Thinking multiple query parameters define routes
• Assuming query parameters only work with POST

2. Which of the following is the correct way to declare two query parameters name (string) and age (integer) in a FastAPI path operation function?

easy

A. def read_user(name: str = Query(...), age: int = Query(...)):

B. def read_user(name: str, age: int = None):

C. def read_user(name: int, age: str):

D. def read_user(name, age):

Solution

1. Step 1: Understand FastAPI query parameter declaration

   Using Query(...) marks parameters as required query parameters with type hints.

2. Step 2: Check parameter types and usage

   Parameters must have correct types and use Query(...) to be recognized as query parameters.

3. Final Answer:

   def read_user(name: str = Query(...), age: int = Query(...)): -> Option A

4. Quick Check:

   Use Query(...) with correct types for query parameters [OK]

Hint: Use Query(...) with type hints for required query parameters [OK]

Common Mistakes:

• Swapping types of parameters
• Not using Query for required parameters
• Omitting type hints

3. Given this FastAPI endpoint code:

from fastapi import FastAPI, Query
from typing import List

app = FastAPI()

@app.get('/items/')
async def read_items(q: List[str] = Query([])):
    return {"q": q}

What will be the output if the URL is /items/?q=apple&q=banana?

medium

A. {"q": ["apple"]}

B. {"q": "apple,banana"}

C. {"q": ["apple", "banana"]}

D. {"q": []}

Solution

1. Step 1: Understand List query parameters in FastAPI

   Using List[str] with Query([]) allows multiple values for the same query key to be collected into a list.

2. Step 2: Analyze the URL query parameters

   The URL has q=apple and q=banana, so FastAPI collects both into a list.

3. Final Answer:

   {"q": ["apple", "banana"]} -> Option C

4. Quick Check:

   Multiple query keys = list of values [OK]

Hint: Multiple same keys in URL become list in FastAPI [OK]

Common Mistakes:

• Expecting a single string with commas
• Getting only the first value
• Getting an empty list

4. What is wrong with this FastAPI endpoint code that tries to accept two query parameters name and age?:

from fastapi import FastAPI
app = FastAPI()

@app.get('/user/')
def get_user(name: str, age: int = None):
    return {"name": name, "age": age}

medium

A. The route path should not end with a slash

B. The function must be async

C. Missing Query() for both parameters

D. The parameter age should use Optional[int] for optional query

Solution

1. Step 1: Check optional query parameter typing

   In FastAPI, optional parameters should use Optional[type] or type | None to mark them optional properly.

2. Step 2: Analyze age: int = None

   Just setting default to None is not enough; the type hint should be Optional[int] or int | None for FastAPI to treat it as optional.

3. Final Answer:

   The parameter age should use Optional[int] for optional query -> Option D

4. Quick Check:

   Optional query params need Optional[type] or type | None [OK]

Hint: Use Optional[int] or int | None for optional query params [OK]

Common Mistakes:

• Assuming default None alone makes param optional
• Forgetting to import Optional
• Thinking async is required for all endpoints

5. You want to create a FastAPI endpoint that accepts multiple optional query parameters: tags (list of strings), limit (integer, default 10), and search (optional string). Which of the following function signatures correctly implements this?

hard

A. def get_items(tags: List[str] = Query([]), limit: int = 10, search: str = None):

B. def get_items(tags: List[str] = Query([]), limit: int = Query(10), search: Optional[str] = Query(None)):

C. def get_items(tags: List[str] = [], limit: int = 10, search: str = ''):

D. def get_items(tags: List[str], limit: int = Query(10), search: Optional[str] = Query(None)):

Solution

1. Step 1: Use Query() for query parameters with defaults

   FastAPI requires using Query() to specify default values and metadata for query parameters.

2. Step 2: Correctly type optional parameters

   Use Optional[str] or str | None with Query(None) for optional string parameters.

3. Step 3: Check all parameters in def get_items(tags: List[str] = Query([]), limit: int = Query(10), search: Optional[str] = Query(None)):

   def get_items(tags: List[str] = Query([]), limit: int = Query(10), search: Optional[str] = Query(None)): uses Query([]) for list default, Query(10) for limit default, and Optional[str] = Query(None) for optional search, which is correct.

4. Final Answer:

   def get_items(tags: List[str] = Query([]), limit: int = Query(10), search: Optional[str] = Query(None)): -> Option B

5. Quick Check:

   Use Query() with correct types and defaults for multiple optional queries [OK]

Hint: Use Query() with defaults and Optional for optional query params [OK]

Common Mistakes:

• Using mutable default [] without Query()
• Not marking optional string with Optional
• Omitting Query() for default values