Why routing organizes endpoints in FastAPI - See It in Action

Why routing organizes endpoints

📖 Scenario: You are building a simple web API for a bookstore. You want to organize your code so that different parts of the API handle different tasks clearly and neatly.

🎯 Goal: Build a FastAPI app that uses routing to organize endpoints for books and authors separately.

📋 What You'll Learn

Create a FastAPI app instance called app

Create two routers: books_router and authors_router

Add one GET endpoint to books_router at path /books/ that returns a list of book titles

Add one GET endpoint to authors_router at path /authors/ that returns a list of author names

Include both routers in the main app with prefixes /books and /authors respectively

💡 Why This Matters

🌍 Real World

Web APIs often have many endpoints. Routing helps keep code organized and scalable.

💼 Career

Understanding routing is essential for backend developers building APIs with FastAPI or similar frameworks.

1

Create the FastAPI app and routers

Import FastAPI and APIRouter from fastapi. Create a FastAPI app instance called app. Create two routers called books_router and authors_router using APIRouter().

FastAPI

from fastapi import FastAPI, APIRouter

# Create the FastAPI app instance

# Create the books_router

# Create the authors_router

Hint

Use app = FastAPI() to create the app. Use APIRouter() to create routers.

2

Add GET endpoint to books_router

Add a GET endpoint to books_router at path /books/ that returns a list of book titles: ["The Hobbit", "1984", "Pride and Prejudice"]. Use the decorator @books_router.get("/") and define a function called get_books.

FastAPI

from fastapi import FastAPI, APIRouter

app = FastAPI()

books_router = APIRouter()
authors_router = APIRouter()

# Add GET endpoint to books_router

Hint

Use @books_router.get("/") to create the endpoint. Return the exact list of book titles.

3

Add GET endpoint to authors_router

Add a GET endpoint to authors_router at path /authors/ that returns a list of author names: ["J.R.R. Tolkien", "George Orwell", "Jane Austen"]. Use the decorator @authors_router.get("/") and define a function called get_authors.

FastAPI

from fastapi import FastAPI, APIRouter

app = FastAPI()

books_router = APIRouter()
authors_router = APIRouter()

@books_router.get("/")
async def get_books():
    return ["The Hobbit", "1984", "Pride and Prejudice"]

# Add GET endpoint to authors_router

Hint

Use @authors_router.get("/") to create the endpoint. Return the exact list of author names.

4

Include routers in the main app with prefixes

Include books_router in app with prefix /books. Include authors_router in app with prefix /authors. Use app.include_router() for both.

FastAPI

from fastapi import FastAPI, APIRouter

app = FastAPI()

books_router = APIRouter()
authors_router = APIRouter()

@books_router.get("/")
async def get_books():
    return ["The Hobbit", "1984", "Pride and Prejudice"]

@authors_router.get("/")
async def get_authors():
    return ["J.R.R. Tolkien", "George Orwell", "Jane Austen"]

# Include routers in app with prefixes

Hint

Use app.include_router() with the correct router and prefix.

Practice

1. Why does FastAPI use routing to organize endpoints in an application?

easy

A. To create user interfaces without HTML

B. To make the app run faster by skipping functions

C. To connect specific URLs to the functions that handle them

D. To store data in a database automatically

Solution

1. Step 1: Understand routing purpose

   Routing links URLs (web addresses) to the code that runs when those URLs are visited.

2. Step 2: Match routing with function handling

   FastAPI uses routing to tell which function should respond to each URL.

3. Final Answer:

   To connect specific URLs to the functions that handle them -> Option C

4. Quick Check:

   Routing = URL to function link [OK]

Hint: Routing links URLs to functions handling requests [OK]

Common Mistakes:

• Thinking routing speeds up the app by skipping code
• Confusing routing with database storage
• Believing routing creates user interfaces

2. Which of the following is the correct way to define a GET route in FastAPI for the URL /items/?

easy

A. @app.get('/items')
def get_items():
return {'items': []}

B. @app.route('/items/')
def get_items():
return {'items': []}

C. @app.get_items('/items/')
def get_items():
return {'items': []}

D. @app.get('/items/')
def get_items():
return {'items': []}

Solution

1. Step 1: Identify FastAPI route decorator

   FastAPI uses @app.get() to define GET routes, not @app.route() or @app.get_items().

2. Step 2: Check URL syntax

   Both /items/ and /items work, but the question asks for /items/ exactly, so the decorator must match.

3. Final Answer:

   @app.get('/items/') def get_items(): return {'items': []} -> Option D

4. Quick Check:

   Use @app.get() for GET routes [OK]

Hint: Use @app.get() decorator for GET routes [OK]

Common Mistakes:

• Using @app.route() which is not FastAPI syntax
• Using incorrect decorator names like @app.get_items()
• Missing trailing slash when required

3. What will be the output when accessing the URL /hello in this FastAPI app?

from fastapi import FastAPI
app = FastAPI()

@app.get('/hello')
def say_hello():
    return {'message': 'Hello, FastAPI!'}

medium

A. {"message": "Hello, FastAPI!"}

B. Hello, FastAPI!

C. 404 Not Found error

D. SyntaxError

Solution

1. Step 1: Identify route and function output

   The route /hello returns a dictionary with key 'message' and value 'Hello, FastAPI!'.

2. Step 2: Understand FastAPI response format

   FastAPI automatically converts dictionaries to JSON responses, so the output is JSON with the message.

3. Final Answer:

   {"message": "Hello, FastAPI!"} -> Option A

4. Quick Check:

   Dict return = JSON response [OK]

Hint: FastAPI returns dicts as JSON automatically [OK]

Common Mistakes:

• Expecting plain text instead of JSON
• Thinking the route does not exist (404)
• Assuming syntax errors without checking code

4. Identify the error in this FastAPI route definition:

from fastapi import FastAPI
app = FastAPI()

@app.get('/users')
def get_users():
return {'users': ['Alice', 'Bob']}

medium

A. Incorrect decorator name @app.get

B. Missing indentation for the function body

C. Route URL should be '/users/' with trailing slash

D. Function must return a list, not a dictionary

Solution

1. Step 1: Check Python syntax indentation

   The function body must be indented under the function definition. Here, return is not indented, causing a syntax error.

2. Step 2: Verify decorator and return type

   The decorator @app.get is correct, and returning a dictionary is valid for JSON response.

3. Final Answer:

   Missing indentation for the function body -> Option B

4. Quick Check:

   Python requires indentation for function bodies [OK]

Hint: Check indentation after function definitions [OK]

Common Mistakes:

• Ignoring Python indentation rules
• Changing correct decorator names
• Thinking trailing slash is mandatory

5. You want to organize your FastAPI app with multiple routes for users and items. Which approach best keeps your code clean and easy to maintain?

hard

A. Use FastAPI's APIRouter to group related routes and include them in the main app

B. Define all routes directly in the main app file without grouping

C. Write all route functions inside a single large function

D. Create separate Python files but do not connect them to the main app

Solution

1. Step 1: Understand code organization needs

   When an app grows, grouping related routes helps keep code clean and easier to read.

2. Step 2: Use APIRouter for grouping

   FastAPI provides APIRouter to group routes logically and then include them in the main app, improving structure and maintenance.

3. Final Answer:

   Use FastAPI's APIRouter to group related routes and include them in the main app -> Option A

4. Quick Check:

   APIRouter groups routes for clean code [OK]

Hint: Group routes with APIRouter for clean structure [OK]

Common Mistakes:

• Putting all routes in one file without grouping
• Writing all routes inside one function
• Not connecting separate files to the main app