Shared dependencies across routers in FastAPI - Step-by-Step Execution

Concept Flow - Shared dependencies across routers

Define Dependency Function

↓

Create Router A with Dependency

↓

Create Router B with Dependency

↓

Include Routers in Main App

↓

Request to Router A or B

↓

Dependency Injected Automatically

↓

Endpoint Executes Using Dependency

This flow shows how a single dependency function is defined once and shared across multiple routers, which are then included in the main FastAPI app. When a request hits any router, the shared dependency is automatically injected.

Execution Sample

FastAPI

from fastapi import FastAPI, APIRouter, Depends

def common_dep():
    return "shared data"

router_a = APIRouter(dependencies=[Depends(common_dep)])
router_b = APIRouter(dependencies=[Depends(common_dep)])

app = FastAPI()
app.include_router(router_a)
app.include_router(router_b)

Defines a shared dependency and attaches it to two routers so both use it automatically.

Execution Table

Step	Action	Dependency Called	Router	Result
1	Define common_dep function	No	N/A	Function ready
2	Create router_a with Depends(common_dep)	No	router_a	Router ready with dependency
3	Create router_b with Depends(common_dep)	No	router_b	Router ready with dependency
4	Include router_a and router_b in FastAPI app	No	app	App ready with routers
5	Request to router_a endpoint	Yes	router_a	common_dep runs, returns 'shared data'
6	Request to router_b endpoint	Yes	router_b	common_dep runs, returns 'shared data'
7	Request to app root (no dependency)	No	app	No dependency called
Exit	No more requests	N/A	N/A	Execution ends

💡 No more requests to routers, execution stops

Variable Tracker

Variable	Start	After Step 5	After Step 6	Final
common_dep result	N/A	"shared data"	"shared data"	"shared data"
router_a dependencies	Depends(common_dep)	Depends(common_dep)	Depends(common_dep)	Depends(common_dep)
router_b dependencies	Depends(common_dep)	Depends(common_dep)	Depends(common_dep)	Depends(common_dep)

Key Moments - 2 Insights

Why does common_dep run on requests to both router_a and router_b?

Because both routers include Depends(common_dep) in their dependencies list, so FastAPI injects it automatically on requests to any endpoint in those routers (see execution_table rows 5 and 6).

Does common_dep run when requesting the main app root without routers?

No, because the main app root does not have the dependency attached, so common_dep is not called (see execution_table row 7).

Visual Quiz - 3 Questions

Look at the execution table, what is the result of common_dep when a request hits router_b?

A "router_b"

B "shared data"

C None

D Error

💡 Hint

Check execution_table row 6 where router_b request calls common_dep returning 'shared data'

At which step does the dependency get injected for the first time?

A Step 5

B Step 2

C Step 4

D Step 1

💡 Hint

Look at execution_table row 5 where the first request triggers dependency injection

If we remove Depends(common_dep) from router_a, what changes in the execution table?

A Step 6 no longer calls common_dep

B Step 7 calls common_dep

C Step 5 no longer calls common_dep

D No changes

💡 Hint

Refer to variable_tracker and execution_table rows 5 and 6 about which routers have the dependency

Concept Snapshot

Shared dependencies in FastAPI allow you to define a function once
and attach it to multiple routers using Depends().
When a request hits any router with that dependency,
FastAPI runs the dependency automatically.
This avoids repeating code and keeps routers clean.
Include routers in the main app to activate them.

Full Transcript

In FastAPI, you can create a dependency function that provides shared data or logic. This function is defined once, for example common_dep, which returns 'shared data'. You then create routers, like router_a and router_b, and attach this dependency to them using the dependencies parameter with Depends(common_dep). When you include these routers in the main FastAPI app, any request to endpoints inside these routers will automatically call common_dep before running the endpoint code. This means the shared dependency runs for both routers without repeating code. If you request the main app root without routers, the dependency does not run. This setup helps keep your code organized and efficient by sharing common logic across multiple routers.