✦

AI Reading

Quick summary of this article

FastAPI automatically generates interactive API documentation using OpenAPI standards, providing Swagger UI at /docs for testing endpoints directly from the browser and ReDoc at /redoc for a clean, readable reference view. The documentation is built from your code by reading function signatures, type hints, Pydantic models, and docstrings, making your API self-documenting and easy for developers and stakeholders to use.

• Swagger UI lets you test endpoints directly from the browser using the "Try it out" button, showing request URLs, curl commands, and response data.
• Use tags to organize endpoints into groups (like "users" or "items") for cleaner navigation in larger APIs.
• Customize documentation by adding metadata to the FastAPI app, including title, description, version, contact information, and license details.
• Add response models, examples using schema_extra, and endpoint summaries with Markdown descriptions to make documentation more useful for API consumers.
• The OpenAPI schema is available at /openapi.json and can be exported for use with third-party tools to generate PDF or standalone HTML documentation.

Introduction

Welcome to Module 6 of our FastAPI Complete Course. In previous modules, you learned how to build endpoints, handle data validation with Pydantic, and manage dependencies. Now, we will explore one of FastAPI’s most powerful features: its automatic API documentation. When you build a professional API, documentation is not an afterthought—it is a critical deliverable. With FastAPI, you get interactive documentation for free, based on the OpenAPI standard.

In this chapter, we will cover FastAPI API Documentation in depth. You will learn how to use Swagger UI and ReDoc, how to test your APIs directly from the docs, how schema generation works under the hood, and how to customize the documentation to make it production-ready. By the end, you will be able to ship APIs that are self-documenting and easy for frontend developers, testers, and stakeholders to use.

Swagger UI

Swagger UI is the default interactive documentation interface provided by FastAPI. When you run your application and visit /docs, you see a beautiful, interactive page where you can explore all your endpoints, see request bodies, and even execute requests directly from the browser.

How Swagger UI is Generated

FastAPI automatically reads your path operations, Pydantic models, and parameter definitions to generate an OpenAPI schema. Swagger UI then renders that schema as an interactive web page. You do not need to install anything extra—FastAPI ships with Swagger UI built-in.

Enabling Swagger UI

Swagger UI is enabled by default. To verify, create a simple FastAPI app and visit http://localhost:8000/docs.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

When you run this app with uvicorn main:app --reload and navigate to /docs, you will see two endpoints listed. Each endpoint shows the HTTP method, the path, and a “Try it out” button. Clicking “Try it out” allows you to fill in parameters and execute the request directly from the browser.

Understanding the Swagger UI Interface

• Endpoints List: All registered routes are shown grouped by tags (if defined).
• Parameters: Path parameters, query parameters, headers, and request bodies are displayed with their types and validation rules.
• Schemas: At the bottom, you will see a “Schemas” section that lists all Pydantic models used in your API.
• Response Codes: Each endpoint shows possible response codes (200, 422, etc.) with example responses.

Using Tags to Organize Endpoints

For larger APIs, you should group endpoints using the tags parameter. This makes Swagger UI much more readable.

from fastapi import FastAPI

app = FastAPI()

@app.get("/users/", tags=["users"])
def get_users():
    return [{"username": "alice"}, {"username": "bob"}]

@app.post("/users/", tags=["users"])
def create_user(username: str):
    return {"username": username, "created": True}

@app.get("/items/", tags=["items"])
def get_items():
    return [{"item": "laptop"}, {"item": "mouse"}]

Now in Swagger UI, endpoints are grouped under “users” and “items” sections. This is essential for job-ready APIs that have dozens of endpoints.

ReDoc Documentation

While Swagger UI is interactive, ReDoc provides a clean, documentation-focused view. It is ideal for sharing with frontend developers or stakeholders who want to read the API specification in a more traditional documentation layout.

Accessing ReDoc

ReDoc is available at /redoc by default. Using the same app as above, visit http://localhost:8000/redoc. You will see a three-panel layout: a navigation sidebar on the left, the main content in the center, and request/response examples on the right.

Key Differences Between Swagger UI and ReDoc

• Swagger UI: Interactive, allows “Try it out” functionality, best for development and testing.
• ReDoc: Read-only, clean layout, better for documentation distribution and client onboarding.

Customizing ReDoc Appearance

You can customize the ReDoc page by passing parameters to the Redoc class. However, the easiest way is to use FastAPI’s built-in support. You can also disable one or the other if needed.

from fastapi import FastAPI
from fastapi.openapi.docs import get_redoc_html

app = FastAPI(docs_url=None, redoc_url=None)

@app.get("/docs", include_in_schema=False)
async def custom_swagger():
    return get_swagger_html(openapi_url="/openapi.json", title="My API")

@app.get("/redoc", include_in_schema=False)
async def custom_redoc():
    return get_redoc_html(openapi_url="/openapi.json", title="My API")

This gives you full control over the documentation endpoints. For most beginners, the defaults are perfectly fine.

Testing APIs

One of the best features of FastAPI documentation is that you can test your APIs directly from Swagger UI without writing any client code. This is invaluable during development and debugging.

Using “Try it out” in Swagger UI

1. Open /docs in your browser.
2. Click on any endpoint to expand it.
3. Click the “Try it out” button on the right.
4. Fill in the parameters (path, query, or body).
5. Click “Execute”.
6. View the request URL, curl command, and response body.

Testing with curl from Documentation

Swagger UI also shows the equivalent curl command for every request. This is extremely helpful when you need to test the API from a terminal or share the exact request with a colleague.

curl -X 'GET' 
  'http://localhost:8000/items/42?q=test' 
  -H 'accept: application/json'

Testing with Python Requests

You can also use the documentation to generate Python code. While Swagger UI does not do this automatically, you can easily translate the curl command:

import requests

response = requests.get(
    "http://localhost:8000/items/42",
    params={"q": "test"}
)
print(response.json())

Testing Error Responses

Always test error scenarios. For example, if you have a path parameter that expects an integer, try passing a string. Swagger UI will show you the 422 validation error response, which is crucial for understanding how FastAPI handles invalid data.

API Schema Generation

Behind the scenes, FastAPI generates an OpenAPI schema (formerly known as Swagger specification). This is a JSON or YAML file that describes your entire API. Understanding this schema is key to mastering FastAPI API Documentation.

Accessing the OpenAPI Schema

By default, the schema is available at /openapi.json. Visit this URL in your browser to see the raw JSON.

{
  "openapi": "3.1.0",
  "info": {
    "title": "FastAPI",
    "version": "0.1.0"
  },
  "paths": {
    "/items/{item_id}": {
      "get": {
        "summary": "Read Item",
        "operationId": "read_item_items__item_id__get",
        "parameters": [
          {
            "name": "item_id",
            "in": "path",
            "required": true,
            "schema": {
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "description": "Successful Response",
            "content": {
              "application/json": {
                "schema": {}
              }
            }
          }
        }
      }
    }
  }
}

How Schema is Built

FastAPI inspects your code at startup:

• It reads function signatures to extract parameters.
• It reads type hints to determine data types.
• It reads Pydantic models to generate JSON Schema for request/response bodies.
• It reads docstrings and metadata to populate descriptions.

Using Pydantic Models for Schema

Pydantic models are the backbone of schema generation. They ensure that your API documentation accurately reflects the data structure.

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = False

@app.post("/items/")
def create_item(item: Item):
    return {"item_name": item.name, "price_with_tax": item.price * 1.1}

In the generated schema, the Item model will appear under the “schemas” section with all its fields, types, and default values. This is automatically used by both Swagger UI and ReDoc.

Schema Caching

FastAPI caches the schema for performance. If you change your models, you need to restart the server (or use --reload) to see the updates in the documentation.

Customizing Documentation

Out of the box, FastAPI gives you great documentation. But for a professional API, you will want to customize it. This includes adding a title, description, version, contact information, and more.

Setting API Metadata

You can pass metadata to the FastAPI() constructor:

from fastapi import FastAPI

app = FastAPI(
    title="E-Commerce API",
    description="This is a sample e-commerce API built with FastAPI. It supports product listing, user management, and order processing.",
    version="2.5.0",
    terms_of_service="http://example.com/terms/",
    contact={
        "name": "API Support",
        "url": "http://example.com/contact/",
        "email": "support@example.com",
    },
    license_info={
        "name": "Apache 2.0",
        "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
    },
)

This metadata will appear at the top of both Swagger UI and ReDoc. It also appears in the /openapi.json schema.

Adding Descriptions to Path Operations

You can add a summary and description to each endpoint. The description supports Markdown for rich formatting.

@app.get("/products/", summary="List all products", description="Returns a list of all products in the catalog. Supports pagination.")
def list_products():
    return [{"id": 1, "name": "Laptop"}, {"id": 2, "name": "Mouse"}]

Using Response Models and Examples

Response models tell FastAPI what the response will look like. This improves documentation and adds automatic validation.

from pydantic import BaseModel
from typing import List

class Product(BaseModel):
    id: int
    name: str
    price: float

    class Config:
        schema_extra = {
            "example": {
                "id": 1,
                "name": "Wireless Mouse",
                "price": 29.99
            }
        }

@app.get("/products/", response_model=List[Product])
def list_products():
    return [{"id": 1, "name": "Laptop", "price": 999.99}]

The schema_extra in the Pydantic model provides example data that appears in the documentation. This is extremely helpful for consumers of your API.

Customizing OpenAPI with openapi_tags

You can provide additional metadata for tags, such as descriptions:

tags_metadata = [
    {
        "name": "users",
        "description": "Operations with users. The **login** logic is also here.",
    },
    {
        "name": "items",
        "description": "Manage items. So _fancy_ they have their own docs.",
    },
]

app = FastAPI(openapi_tags=tags_metadata)

Disabling Documentation

For production deployments, you might want to disable the documentation:

app = FastAPI(docs_url=None, redoc_url=None)

Alternatively, you can serve documentation only on specific environments using environment variables.

Common Mistakes

Here are some pitfalls beginners face when working with FastAPI API Documentation:

• Forgetting to restart the server: Changes to metadata or models require a server restart to reflect in the docs.
• Not using response_model: Without response_model, the documentation shows empty response schemas, which is unhelpful.
• Ignoring validation errors: If you do not test 422 responses, you might miss validation issues that confuse API consumers.
• Overly complex models: Deeply nested Pydantic models can make the schema hard to read. Use schema_extra with good examples.
• Not using tags: For APIs with more than 5 endpoints, the documentation becomes messy without tags.

Practice Task

Now it is your turn to apply what you have learned. Build a small API for a library system and customize its documentation.

1. Create a FastAPI app with the title “Library API” and description “Manage books and authors”.
2. Create two Pydantic models: Book (with id, title, author, year) and Author (with id, name, birth_year).
3. Add examples to both models using schema_extra.
4. Create endpoints: GET /books/, POST /books/, GET /authors/, POST /authors/.
5. Use tags to group books and authors.
6. Add summaries and descriptions to each endpoint.
7. Run the server and verify that Swagger UI shows all the metadata correctly.
8. Test the POST /books/ endpoint using the “Try it out” feature with your example data.
9. Check the /openapi.json endpoint to see the full schema.

Once you complete this, you will have a production-ready documentation setup.

Summary

In this module, you learned how FastAPI generates automatic, interactive API documentation. We covered:

• Swagger UI: Interactive documentation at /docs for testing endpoints.
• ReDoc: Clean, readable documentation at /redoc for sharing.
• Testing APIs: Using “Try it out” and curl commands directly from the docs.
• API Schema Generation: How FastAPI creates OpenAPI JSON from your code and Pydantic models.
• Customizing Documentation: Adding titles, descriptions, tags, response models, and examples to make your API professional.

Mastering FastAPI API Documentation is a key skill for any backend developer. It saves time, reduces miscommunication, and makes your API a pleasure to use.

FAQs

1. Can I use both Swagger UI and ReDoc at the same time?

Yes, by default both are enabled. Swagger UI is at /docs and ReDoc is at /redoc. You can disable either by setting the respective URL parameter to None.

2. How do I add authentication to the documentation?

FastAPI supports OpenAPI security schemes. You can add global security using the openapi_security parameter or per-endpoint using dependencies. The documentation will show a “Authorize” button where users can input tokens.

3. Why is my documentation not updating after I change my code?

FastAPI caches the schema. You need to restart the server (or use --reload during development) to see changes. In production, a restart is required.

4. Can I export the documentation as PDF or HTML?

Yes. You can save the /openapi.json file and use tools like redoc-cli to generate a standalone HTML file. There are also third-party tools to convert OpenAPI to PDF.

5. How do I hide certain endpoints from the documentation?

Use the include_in_schema=False parameter in the path decorator. This is useful for internal or deprecated endpoints.

@app.get("/internal/health", include_in_schema=False)
def health_check():
    return {"status": "ok"}

This endpoint will still work but will not appear in Swagger UI or ReDoc.

---

You have now completed Module 6. Your APIs are no longer black boxes—they are well-documented, testable, and professional. In Module 7: Deployment and Production, we will take your FastAPI application and deploy it to the cloud. You will learn about environment variables, CORS, HTTPS, Docker, and deployment to platforms like Heroku and AWS. Get ready to put your API online for the world to use.

More Practical Examples

Let’s expand your understanding of FastAPI’s documentation capabilities with some real-world scenarios. These examples go beyond the basics and show you how to handle common tasks like adding custom headers, describing request bodies in detail, and grouping endpoints logically.

Example 1: Adding Custom Headers to Documentation

Sometimes your API needs a custom header (like an API key or a session token). FastAPI lets you document these headers using the Header class. Here’s how:

from fastapi import FastAPI, Header, HTTPException

app = FastAPI()

@app.get("/items/")
async def read_items(x_api_key: str = Header(...)):
    """
    Retrieve all items. Requires a valid API key in the 'X-API-Key' header.
    """
    if x_api_key != "secret-key":
        raise HTTPException(status_code=403, detail="Invalid API Key")
    return {"items": ["item1", "item2"]}

Explanation: The Header(...) parameter tells FastAPI to expect a header named X-API-Key. The ellipsis (...) makes it required. When you open Swagger UI, you’ll see a field to enter this header. The docstring appears as a description, making the endpoint self-explanatory.

Example 2: Detailed Request Body with Examples

FastAPI allows you to provide example values for request bodies. This is incredibly helpful for frontend developers or other API consumers.

from pydantic import BaseModel, Field

class Item(BaseModel):
    name: str = Field(..., example="Laptop")
    price: float = Field(..., example=999.99)
    in_stock: bool = Field(True, example=True)

@app.post("/items/")
async def create_item(item: Item):
    """
    Create a new item in the inventory.
    """
    return {"item": item}

Explanation: The Field class with the example parameter populates the “Example Value” section in Swagger UI. When users click “Try it out,” they see these prefilled values. This reduces errors and speeds up testing.

Example 3: Grouping Endpoints with Tags

As your API grows, you’ll want to organize endpoints logically. Tags group related operations in the documentation.

from fastapi import FastAPI

app = FastAPI()

@app.get("/users/", tags=["Users"])
async def get_users():
    return [{"username": "alice"}, {"username": "bob"}]

@app.get("/items/", tags=["Items"])
async def get_items():
    return [{"item": "book"}, {"item": "pen"}]

@app.get("/orders/", tags=["Orders"])
async def get_orders():
    return [{"order_id": 1}]

Explanation: Each endpoint is assigned a tags list. In Swagger UI, endpoints are grouped under collapsible sections named after the tags. This makes navigation much easier when you have dozens of routes.

Class-Based Example

While FastAPI functions work well, you might prefer a class-based approach for better organization, especially in larger projects. FastAPI supports this through APIRouter and class-based views using @app.api_route decorators, but the most common pattern is to use dependency injection with classes.

Example: A Class-Based CRUD API with Documentation

from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI()

# In-memory database
items_db = []

class Item(BaseModel):
    id: int
    name: str
    price: float

class ItemCreate(BaseModel):
    name: str
    price: float

class ItemService:
    """Service class for item operations."""
    
    def get_all_items(self) -> List[Item]:
        return items_db
    
    def get_item(self, item_id: int) -> Item:
        for item in items_db:
            if item.id == item_id:
                return item
        raise HTTPException(status_code=404, detail="Item not found")
    
    def create_item(self, item: ItemCreate) -> Item:
        new_id = len(items_db) + 1
        new_item = Item(id=new_id, **item.dict())
        items_db.append(new_item)
        return new_item
    
    def delete_item(self, item_id: int) -> dict:
        for i, item in enumerate(items_db):
            if item.id == item_id:
                items_db.pop(i)
                return {"message": "Item deleted"}
        raise HTTPException(status_code=404, detail="Item not found")

# Dependency to get the service instance
def get_item_service():
    return ItemService()

@app.get("/items/", response_model=List[Item], tags=["Items"])
async def read_items(service: ItemService = Depends(get_item_service)):
    """Get all items."""
    return service.get_all_items()

@app.get("/items/{item_id}", response_model=Item, tags=["Items"])
async def read_item(item_id: int, service: ItemService = Depends(get_item_service)):
    """Get a single item by ID."""
    return service.get_item(item_id)

@app.post("/items/", response_model=Item, status_code=201, tags=["Items"])
async def create_item(item: ItemCreate, service: ItemService = Depends(get_item_service)):
    """Create a new item."""
    return service.create_item(item)

@app.delete("/items/{item_id}", tags=["Items"])
async def delete_item(item_id: int, service: ItemService = Depends(get_item_service)):
    """Delete an item by ID."""
    return service.delete_item(item_id)

Explanation: This example uses a class ItemService to encapsulate business logic. The Depends(get_item_service) dependency injection ensures each endpoint gets a fresh service instance. The documentation automatically picks up the response_model, status codes, and docstrings. Swagger UI will show proper request/response schemas for each endpoint.

Why use classes? They make testing easier (you can mock the service), keep your code DRY, and scale well with complex business logic. The documentation remains clear because FastAPI reads the type hints and docstrings regardless of whether you use functions or classes.

Step-by-Step Exercise

Now it’s your turn! Follow these steps to build a small API with comprehensive documentation. This exercise will reinforce everything you’ve learned.

Objective

Create a simple “Task Manager” API with three endpoints: create a task, list all tasks, and delete a task. Customize the documentation with tags, examples, and descriptions.

Step 1: Set Up Your Project

Create a new file called task_manager.py and add the following imports:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import List

Step 2: Define the Task Model

class Task(BaseModel):
    id: int
    title: str = Field(..., example="Buy groceries")
    completed: bool = Field(False, example=False)

class TaskCreate(BaseModel):
    title: str = Field(..., example="Buy groceries")

Step 3: Create the App and In-Memory Storage

app = FastAPI(title="Task Manager API", description="A simple API to manage tasks.", version="1.0.0")
tasks_db = []

Step 4: Implement the Endpoints

@app.post("/tasks/", response_model=Task, status_code=201, tags=["Tasks"])
async def create_task(task: TaskCreate):
    """Create a new task."""
    new_id = len(tasks_db) + 1
    new_task = Task(id=new_id, **task.dict())
    tasks_db.append(new_task)
    return new_task

@app.get("/tasks/", response_model=List[Task], tags=["Tasks"])
async def list_tasks():
    """List all tasks."""
    return tasks_db

@app.delete("/tasks/{task_id}", tags=["Tasks"])
async def delete_task(task_id: int):
    """Delete a task by ID."""
    for i, task in enumerate(tasks_db):
        if task.id == task_id:
            tasks_db.pop(i)
            return {"message": "Task deleted"}
    raise HTTPException(status_code=404, detail="Task not found")

Step 5: Add Custom Documentation

Modify the app creation to include a description and contact info:

app = FastAPI(
    title="Task Manager API",
    description="Manage your daily tasks with this simple API.",
    version="1.0.0",
    contact={
        "name": "Your Name",
        "email": "your.email@example.com",
    },
    license_info={
        "name": "MIT",
    },
)

Step 6: Run and Test

Start the server:

uvicorn task_manager:app --reload

Open your browser to http://127.0.0.1:8000/docs to see Swagger UI. Test each endpoint:

• Create a task using the “Try it out” button.
• List tasks to see the created task.
• Delete a task by its ID.

Also check http://127.0.0.1:8000/redoc for the ReDoc view. Notice how the title, description, and contact info appear at the top.

Step 7: Verify the Schema

Visit http://127.0.0.1:8000/openapi.json to see the generated OpenAPI schema. This is the JSON that powers both Swagger UI and ReDoc.

Congratulations! You’ve built a fully documented API. This exercise shows how little code is needed to get professional-grade documentation.

Interview and Job Use Cases

Understanding API documentation in FastAPI is not just about writing code—it’s a skill that can set you apart in interviews and on the job. Here’s how this knowledge applies in real-world scenarios.

Interview Questions You Might Encounter

• “How does FastAPI generate documentation automatically?”
  Answer: FastAPI uses Python type hints and Pydantic models to generate an OpenAPI schema, which is then rendered by Swagger UI and ReDoc. The schema includes endpoints, parameters, request bodies, responses, and authentication.
• “How would you add custom metadata to your API documentation?”
  Answer: You can set the title, description, version, contact, and license_info parameters when creating the FastAPI instance. For individual endpoints, use docstrings and the tags parameter.
• “What’s the difference between Swagger UI and ReDoc?”
  Answer: Swagger UI provides an interactive interface where you can test endpoints directly. ReDoc offers a more static, clean, and readable documentation layout, ideal for sharing with non-technical stakeholders.
• “How do you disable documentation in production?”
  Answer: Set docs_url=None and redoc_url=None when creating the FastAPI instance. You can also conditionally enable them based on an environment variable.

Job Use Cases

• Team Collaboration: When working in a team, clear documentation reduces misunderstandings. Frontend developers can see exactly what data an endpoint expects and returns, speeding up integration.
• Client Handoffs: If you’re building an API for a client, ReDoc provides a polished, shareable link that looks professional and requires no explanation.
• Automated Testing: Tools like pytest can use the OpenAPI schema to validate that your API matches its documentation. This catches discrepancies early.
• API Versioning: By documenting version info in the schema, you can maintain multiple API versions and let consumers know which one they’re using.

Real-World Scenario

Imagine you’re building a payment processing API. You need to document sensitive fields like credit card numbers. FastAPI allows you to use Pydantic’s SecretStr type, which masks the value in logs and documentation:

from pydantic import BaseModel, SecretStr

class Payment(BaseModel):
    card_number: SecretStr
    amount: float

In Swagger UI, the card number field will show as ******** when displayed, protecting sensitive data while still being functional.

Extra Beginner FAQs

Here are answers to common questions beginners ask about FastAPI documentation.

Q1: Can I change the URL for Swagger UI and ReDoc?

Yes! Use the docs_url and redoc_url parameters:

app = FastAPI(docs_url="/api/docs", redoc_url="/api/redoc")

Now Swagger UI is at /api/docs instead of /docs.

Q2: How do I add a description to a specific endpoint?

Write a docstring inside the function. FastAPI automatically uses it as the endpoint description:

@app.get("/hello/")
async def hello():
    """This is a friendly greeting endpoint."""
    return {"message": "Hello"}

Q3: What if I don’t want any documentation?

Disable both by setting them to None:

app = FastAPI(docs_url=None, redoc_url=None)

This is common in production environments to reduce exposure.

Q4: Can I add custom CSS or JavaScript to the documentation?

Yes, but it requires overriding the default templates. FastAPI allows you to pass custom templates using Jinja2. This is an advanced topic, but possible for branding purposes.

Q5: Why does my documentation show “string” instead of actual examples?

You need to provide example values in your Pydantic models using Field:

class Item(BaseModel):
    name: str = Field(..., example="Widget")

Q6: How do I document query parameters?

Use the Query class with a description:

from fastapi import Query

@app.get("/items/")
async def read_items(q: str = Query(None, description="Search query")):
    return {"q": q}

Q7: Can I group endpoints by multiple tags?

Yes, pass a list of tags:

@app.get("/admin/", tags=["Admin", "Users"])
async def admin_only():
    return {"message": "Admin area"}

The endpoint will appear under both “Admin” and “Users” sections in Swagger UI.

Q8: How do I handle authentication in documentation?

FastAPI supports OpenAPI security schemes. For example, to add bearer token authentication:

from fastapi.security import HTTPBearer

security = HTTPBearer()

@app.get("/secure/")
async def secure_endpoint(token: str = Depends(security)):
    return {"token": token}

Swagger UI will show an “Authorize” button where users can paste their token.

Q9: My documentation is not updating. What’s wrong?

Make sure you’re running the server with the --reload flag:

uvicorn main:app --reload

Also, clear your browser cache or open the documentation in an incognito window.

Q10: Is it possible to export the documentation as PDF?

Not directly from FastAPI, but you can use third-party tools like widdershins to convert the OpenAPI JSON to Markdown, then to PDF. Alternatively, print the ReDoc page as PDF from your browser.

With these FAQs, you should feel confident troubleshooting and customizing your FastAPI documentation. Remember, the key is to experiment—every change you make is immediately visible in the interactive docs!