Consuming Path Arguments Directly in FastAPI Dependency Functions
The short answer is: Yes, it is fundamentally possible and encouraged to pass Path arguments directly into FastAPI dependency functions.
This feature is a core component of FastAPI's Dependency Injection (DI) system, allowing dependencies to be highly contextual. A dependency can perform validation, authentication, or data fetching based on the URL or request inputs before the route handler ever executes.
Automatic Parameter Resolution Mechanism
FastAPI achieves this by inspecting the signature of your dependency function. If a parameter name in your dependency function (e.g., user_id) matches a parameter name defined in the Path of your route (e.g., /users/{user_id}), FastAPI automatically injects the value from the URL into the dependency function.
Validation and Type Coercion
Dependencies can enforce specific rules or custom data checks directly on the Path argument, utilizing FastAPI's powerful validation tools (Path(), Query(), etc.).
from fastapi import FastAPI, Depends, Path, HTTPException
from typing import Annotated
app = FastAPI()
# 1. Dependency Function: Uses the Path argument name 'user_id'
def validate_user_id(
# FastAPI resolves this 'user_id' parameter from the route path
user_id: Annotated[int, Path(ge=100)]
) -> int:
"""
Ensures the user_id is an integer greater than or equal to 100
and is an even number.
"""
# Custom business logic check
if user_id % 2 != 0:
raise HTTPException(status_code=400, detail="User ID must be an even number.")
# Return the validated value
return user_id
# 2. Type Alias for clean route definition
ValidatedUserID = Annotated[int, Depends(validate_user_id)]
# 3. Route Definition
@app.get("/users/{user_id}")
def read_user(user_id: ValidatedUserID):
# This route is guaranteed to receive a valid, even, and large user_id
return {"message": f"Access granted for user {user_id}"}
Dynamic Data Fetching and Loading
Instead of just validating the ID, the dependency can use the Path argument to load the complete associated resource (e.g., fetching a database record) and inject the object directly into the route handler.
# Mock database function
class Record:
def __init__(self, id, data):
self.id = id
self.data = data
def fetch_database_record(record_id: int) -> Record:
"""Mocks fetching a record based on ID."""
if record_id == 404:
raise HTTPException(status_code=404, detail="Record not found.")
return Record(id=record_id, data=f"Loaded data for record {record_id}")
# 1. Dependency Function
def get_verified_record(
record_id: Annotated[int, Path()] # Consumes the Path argument
) -> Record:
"""
Fetches the actual record object using the ID from the path.
"""
# The dependency runs the expensive database lookup
record = fetch_database_record(record_id)
return record
# 2. Type Alias
VerifiedRecord = Annotated[Record, Depends(get_verified_record)]
# 3. Route Definition
@app.put("/records/{record_id}")
def update_record(verified_record: VerifiedRecord):
# The route handler receives the fully loaded Record object, not just the ID.
return {"status": "updated", "record_id": verified_record.id}
Combining Path, Query, and Header in One Dependency
A single dependency function can be designed to consume input from multiple request locations simultaneously, centralizing complex access control logic.
from fastapi import Query, Header
# 1. Dependency Function
def check_dynamic_access(
# Input from Path
item_id: Annotated[int, Path()],
# Input from Query string
scope: Annotated[str, Query(default="read")],
# Input from Request Header
user_role: Annotated[str, Header(alias="X-User-Role")]
) -> bool:
"""
Checks if the user has permission based on the Path ID, Query scope, and Header role.
"""
# Example logic: Only Admins can modify high-ID items
if user_role != "admin" and scope == "modify" and item_id > 1000:
raise HTTPException(
status_code=403,
detail="Admin rights required for modifying items > 1000."
)
return True
# 2. Type Alias (Dependency used for side-effect validation)
CanAccess = Annotated[bool, Depends(check_dynamic_access)]
# 3. Route Definition
# Example URL: /api/1001?scope=modify (with X-User-Role: editor) -> Fails 403
@app.get("/api/{item_id}")
def handle_request(can_access: CanAccess):
# This route only executes if the complex, multi-source access check passed.
return {"message": "Request successfully processed after access checks."}