How does dependency injection (Depends) work?

Question

Accepted Answer

FastAPI's **dependency injection** system lets you declare reusable dependencies (functions/classes) that FastAPI calls and **injects** into your path operations via `Depends()`. It's used for shared logic like database sessions, authentication, and common parameters — keeping code DRY and testable.

## A basic dependency

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

Declaring `params = Depends(pagination)` tells FastAPI to call `pagination` (resolving *its* parameters from the request too) and pass the result into your function. The dependency is reusable across many endpoints.

## Dependencies with cleanup (yield) — e.g. database sessions

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

A `yield` dependency provides a resource and runs teardown after the request — the standard pattern for database sessions (open before, close after, automatically).

## Dependencies can depend on dependencies

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

Dependencies form a tree — FastAPI resolves the whole chain. This is how authentication is typically done (a `get_current_user` dependency).

## Class dependencies and reuse

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## Why it matters

Dependency injection is one of FastAPI's most powerful and important features — it's how you share and reuse logic cleanly across endpoints (database sessions, authentication, common query parameters, permission checks) without duplication.

Understanding it is essential because it underpins core patterns: the **`yield` dependency** is the standard way to manage database sessions (with guaranteed cleanup after each request), and a **`get_current_user` dependency** is the idiomatic way to implement authentication.

DI also makes code highly **testable** — you can override dependencies with mocks in tests.

The system's elegance (dependencies resolve their own parameters from the request, can depend on other dependencies forming a tree, and integrate with the docs) makes it a versatile tool for structuring real applications, so mastering `Depends` is key to building well-organized, maintainable, testable FastAPI apps.