APIRouter for modular routes in FastAPI - Step-by-Step Execution

Concept Flow - APIRouter for modular routes

Create APIRouter instance

↓

Define routes on router

↓

Create main FastAPI app

↓

Include router in main app

↓

Start server and handle requests

↓

Request matches router path -> router handles it

This flow shows how to create a router, add routes, include it in the main app, and handle requests modularly.

Execution Sample

FastAPI

from fastapi import FastAPI, APIRouter

router = APIRouter()

@router.get('/hello')
async def say_hello():
    return {'msg': 'Hello from router!'}

app = FastAPI()
app.include_router(router)

Defines a router with a GET route '/hello' that returns a greeting message, then creates a FastAPI app and includes the router.

Execution Table

Step	Action	Evaluation	Result
1	Create APIRouter instance	router = APIRouter()	router object created
2	Define GET route '/hello' on router	@router.get('/hello')	Route added to router
3	Define async function say_hello	async def say_hello()	Function ready to handle requests
4	Create main FastAPI app	app = FastAPI()	app object created
5	Include router in app	app.include_router(router)	Router routes added to app
6	Start server and receive GET /hello request	Request matches '/hello'	say_hello() called, returns {'msg': 'Hello from router!'}
7	Send response to client	Response sent	Client receives JSON {'msg': 'Hello from router!'}
8	No more requests	Server waits	Execution idle until next request

💡 Server runs indefinitely; execution trace ends after handling one request.

Variable Tracker

Variable	Start	After Step 1	After Step 5	After Step 6	Final
router	undefined	APIRouter instance	APIRouter with route '/hello'	Same	Same
app	undefined	undefined	FastAPI instance with router included	Same	Same
say_hello	undefined	undefined	Defined async function	Called on request	Same

Key Moments - 3 Insights

Why do we create an APIRouter instead of adding routes directly to FastAPI app?

APIRouter lets us group routes separately for better organization and modularity, as shown in steps 1-5 where router is created and included in the main app.

How does the app know to use the routes defined in the router?

In step 5, including the router with app.include_router(router) connects router routes to the app, so requests matching router paths are handled by router functions.

What happens when a request matches a router path?

At step 6, the request triggers the router's route handler function (say_hello), which runs and returns the response, as shown in the execution table.

Visual Quiz - 3 Questions

Look at the execution table, what is the state of 'router' after step 5?

A FastAPI app instance

B Undefined

C APIRouter instance with route '/hello' added

D Function say_hello

💡 Hint

Check the 'variable_tracker' row for 'router' after step 5.

At which step does the FastAPI app include the router?

A Step 2

B Step 5

C Step 4

D Step 6

💡 Hint

Look at the 'Action' column in the execution table for including router.

If we add another route to the router after step 2, how would the execution table change?

A A new step would appear after step 2 showing route addition

B Step 5 would be removed

C Step 6 would not call say_hello anymore

D No change in the table

💡 Hint

Adding routes modifies router before inclusion, so it appears as a new step.

Concept Snapshot

APIRouter lets you group routes separately.
Create router = APIRouter(), add routes with @router.get/post.
Create main app = FastAPI(), then include router with app.include_router(router).
Requests matching router paths call router handlers.
This keeps code modular and organized.

Full Transcript

This visual trace shows how to use APIRouter in FastAPI to organize routes modularly. First, an APIRouter instance is created. Then, routes like GET '/hello' are defined on this router. Next, a main FastAPI app is created. The router is included into the main app using app.include_router(router). When the server runs and receives a request matching '/hello', the router's handler function say_hello is called, returning a JSON response. This modular approach helps keep route code clean and separated. Variables like 'router' and 'app' change state as routes are added and included. Key moments include understanding why routers are used, how inclusion connects routes, and how requests trigger router handlers. The quiz checks understanding of router state, inclusion step, and adding routes. The snapshot summarizes the modular routing pattern with APIRouter.