Basic query parameter declaration in FastAPI - Performance & Optimization

Performance: Basic query parameter declaration

LOW IMPACT

This affects how quickly the server can parse and handle incoming query parameters, impacting response time and user experience.

Handling query parameters in an API endpoint

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def read_items(q: str | None = None):
    # Let FastAPI handle query parameter parsing automatically
    return {"q": q}

FastAPI automatically parses query parameters efficiently, reducing CPU work and simplifying code.

📈 Performance GainSaves ~5-10ms per request; reduces code complexity and potential bugs

Handling query parameters in an API endpoint

FastAPI

from fastapi import FastAPI
app = FastAPI()

@app.get("/items")
def read_items(q: str = None):
    # Manually parse query string inside the function
    # instead of using FastAPI's automatic parsing
    import urllib.parse
    query_string = "q=example"
    params = urllib.parse.parse_qs(query_string)
    q_value = params.get('q', [None])[0]
    return {"q": q_value}

Manually parsing query parameters inside the function duplicates work FastAPI already does, adding unnecessary CPU and code complexity.

📉 Performance CostBlocks request handling longer due to extra parsing; adds ~5-10ms overhead per request

Performance Comparison

Pattern	CPU Overhead	Code Complexity	Response Time Impact	Verdict
Manual query parsing inside endpoint	High (extra parsing)	High (more code)	Increases by ~5-10ms	[X] Bad
FastAPI automatic query parameter declaration	Low (built-in)	Low (simple code)	Minimal impact	[OK] Good

Rendering Pipeline

When a request arrives, FastAPI extracts query parameters before calling the endpoint function. Efficient parsing reduces server processing time, improving response speed.

→Request Parsing

→Endpoint Execution

⚠️ BottleneckManual parsing inside endpoint increases CPU time and delays response.

Core Web Vital Affected

INP

This affects how quickly the server can parse and handle incoming query parameters, impacting response time and user experience.

Optimization Tips

1Declare query parameters in FastAPI function signatures to leverage automatic parsing.

2Avoid manual query string parsing inside endpoint functions to reduce CPU overhead.

3Efficient query parsing improves server response time and user interaction speed.

Performance Quiz - 3 Questions

What is the performance benefit of declaring query parameters directly in FastAPI endpoint functions?

A FastAPI parses parameters efficiently, reducing server CPU time.

B It increases bundle size significantly.

C It causes more layout shifts in the browser.

D It blocks rendering on the client side.

DevTools: Network

How to check: Open DevTools, go to Network tab, make a request to the endpoint, and check the timing breakdown for server response.

What to look for: Look for lower server response time indicating efficient query parameter handling.

Practice

1. In FastAPI, how do you declare a query parameter that is optional with a default value?

easy

A. By importing Query from fastapi and not setting a default value

B. By using a special decorator like @query_param

C. By defining the parameter inside the request body

D. By adding a function parameter with a default value, e.g., def read_item(q: str = None)

Solution

1. Step 1: Understand query parameter declaration

   In FastAPI, query parameters are declared as function parameters in path operation functions.

2. Step 2: Recognize optional parameters

   If a parameter has a default value (like None), it becomes optional and is treated as a query parameter.

3. Final Answer:

   By adding a function parameter with a default value, e.g., def read_item(q: str = None) -> Option D

4. Quick Check:

   Optional query param = default value [OK]

Hint: Optional query params have default values in function signature [OK]

Common Mistakes:

• Thinking a decorator is needed for query params
• Confusing query params with request body
• Not setting a default value makes param required

2. Which of the following is the correct syntax to declare a required query parameter named item_id of type int in FastAPI?

easy

A. def read_item(item_id: int):

B. def read_item(item_id):

C. def read_item(item_id: str = 'default'):

D. def read_item(item_id: int = None):

Solution

1. Step 1: Identify required query parameter syntax

   A required query parameter has no default value and must have a type annotation.

2. Step 2: Check each option

   def read_item(item_id: int): declares item_id as an int without a default, making it required.

3. Final Answer:

   def read_item(item_id: int): -> Option A

4. Quick Check:

   Required param = no default value [OK]

Hint: No default means required query param [OK]

Common Mistakes:

• Setting default None makes param optional
• Using wrong type annotation
• Omitting type annotation makes param a path param

3. What will be the output if you call the FastAPI endpoint defined as below without any query parameters?

from fastapi import FastAPI
app = FastAPI()

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

medium

A. {'q': None}

B. Error: missing required query parameter

C. {'q': 'default'}

D. {'q': ''}

Solution

1. Step 1: Analyze the function parameter

   The parameter q has a default value of 'default', so it is optional.

2. Step 2: Understand the call without query params

   When no query parameter is provided, FastAPI uses the default value 'default'.

3. Final Answer:

   {'q': 'default'} -> Option C

4. Quick Check:

   Default value used when query param missing [OK]

Hint: Default param value is returned if query missing [OK]

Common Mistakes:

• Expecting None instead of default
• Thinking missing param causes error
• Assuming empty string is default

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

from fastapi import FastAPI
app = FastAPI()

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

medium

A. Default value None is invalid for int type without Optional

B. No error, this is a valid optional query parameter

C. Type hint should be Optional[int] from typing

D. Query parameter must be declared with Query()

Solution

1. Step 1: Check parameter declaration

   Declaring user_id: int = None makes it optional with default None.

2. Step 2: Verify FastAPI behavior

   FastAPI accepts this and treats user_id as an optional query parameter.

3. Final Answer:

   No error, this is a valid optional query parameter -> Option B

4. Quick Check:

   Default None with int type is allowed [OK]

Hint: Default None with int type is valid in FastAPI [OK]

Common Mistakes:

• Assuming Optional[int] is required
• Thinking Query() is mandatory
• Confusing type hints with runtime errors

5. You want to declare two query parameters in FastAPI: q which is optional with default None, and limit which is required and an integer. Which is the correct function signature?

hard

A. def read_items(limit: int, q: str = None):

B. def read_items(q: str = None, limit: int):

C. def read_items(q: str, limit: int = None):

D. def read_items(q: str = None, limit: int = 10):

Solution

1. Step 1: Understand parameter order rules

   In Python, parameters without defaults must come before those with defaults.

2. Step 2: Apply to FastAPI query params

   limit is required (no default), so it must come before optional q with default None.

3. Final Answer:

   def read_items(limit: int, q: str = None): -> Option A

4. Quick Check:

   Required params before optional ones [OK]

Hint: Put required params before optional ones in function signature [OK]

Common Mistakes:

• Placing optional param before required causes syntax error
• Assigning default to required param
• Mixing parameter order incorrectly