Why Dependencies with parameters in FastAPI? - Purpose & Use Cases

The Big Idea

Discover how to stop repeating yourself and make your FastAPI routes smarter with just a few lines!

The Scenario

Imagine building a web app where you need to check user permissions or fetch data based on user input for every request manually.

You write repetitive code in every route to handle these checks and data fetching.

The Problem

Manually repeating the same logic in every route is tiring and error-prone.

If you forget to add the check somewhere, your app might expose sensitive data or behave inconsistently.

It also makes your code messy and hard to maintain.

The Solution

FastAPI's dependencies with parameters let you write reusable functions that accept inputs and run automatically before your route logic.

This keeps your routes clean and ensures consistent behavior everywhere.

Before vs After

✗ Before

def get_user(request):
    user_id = request.query_params.get('user_id')
    # manually fetch user and check permissions

@app.get('/items')
def read_items(request):
    user = get_user(request)
    # route logic here

✓ After

from fastapi import Query, Depends
from fastapi import FastAPI

app = FastAPI()

def get_user(user_id: str = Query(...)):
    # fetch user and check permissions
    return user_id

@app.get('/items')
def read_items(user=Depends(get_user)):
    # route logic here
    return {"user": user}

What It Enables

You can build clean, secure, and reusable request handling that adapts based on input parameters automatically.

Real Life Example

In an online store, you can create a dependency that checks if a user is an admin based on a token parameter, and reuse it in all admin routes without repeating code.

Key Takeaways

Manual checks in every route cause repetition and errors.

Dependencies with parameters let you reuse logic with inputs.

This makes your FastAPI code cleaner, safer, and easier to maintain.