Have you ever wondered if you could actually change or edit your /docs or /redoc API documentation page? Or are you tired of seeing the same docs page every time you develop an API? Well, you guessed right if you thought it was possible, because yes, it is.
In this article, discover how to develop and customize your own docs page.

Table of Content:

1. Introduction
2. Prerequisites
3. What FastAPI Gives You By Default
4. Changing the Documetation URLs
5. Disabling Default Docs
6. Creating your own Docs Page
7. Conclusion

Introduction

API Documentation is a feature of an API that gives an overview of an API. That is, its endpoints, the API's current version, etc. FastAPI Documentation is a built-in feature of FastAPI that allows users to have an overview of the capabilities and information about the API, without having to create the API Documentation.

API documentation is an important part of every API because it provides developers with an overview of how the API works, including its available endpoints, request and response formats, authentication methods, current version, and other important details.

One of the reasons many developers love FastAPI is its built-in documentation system. Unlike many backend frameworks where developers need to manually create and maintain documentation, FastAPI automatically generates interactive API documentation out of the box.

With FastAPI, developers can easily test endpoints, inspect request schemas, and understand the capabilities of an API directly from the browser. Even better, FastAPI also allows you to customize these documentation pages to fit your branding, security needs, or developer experience goals.

In this article, we will explore how FastAPI documentation works and how you can create fully custom documentation pages for your APIs.

Prerequisites

To follow along with this article, you should have foreknowledge of the following:

• Basic Frontend Programming (HTML, CSS & JS).
• Basic Python syntax knowledge.
• A General understanding of how APIs work.

Python Packages to install:
FastAPI - The framework to help us create the API.
Uvicorn - A lightning-fast ASGI server to run the FastAPI App.

Run in in your command line:

pip install fastapi uvicorn

What FastAPI Gives You By Default

Create a FastAPI App
To create an API, create a Python file main.py
In this file, type the following:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
    return {"message": "My first API built with FastAPI"}

Then open the file's directory in your command line and type:

uvicorn main:app --reload

Then open your browser and enter http://localhost:8000/ and you will see the API. Like this:

Then FastAPI generates two docs for you:
Swagger UI: http://localhost:8000/docs
Redocly: http://localhost:8000/redoc
Your API's default documentation pages will look like these:
For Swagger:

For Redocly:

Changing the Documentation URLs

One of the things you can customise is the Documentations URLs. You can change the default documentation by changing the parameters of app to this:

app = FastAPI(
    docs_url="/documentation",
    redoc_url="/reference", 
)

When you try to access the /docs or /redoc endpoints, it returns Not Found.

Disabling Default Docs

You can disable the documentations page by setting the parameters of the app variable to None:

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

Creating your own Docs Page

By default, a FastAPI application returns JSON responses for API endpoints. However, since browsers can also render HTML, you can build a fully custom documentation page by returning HTML instead of JSON for a specific route.

To do this, you simply create an endpoint that returns HTML content using FastAPI’s HTMLResponse.

You can also disable the default Swagger and ReDoc documentation pages if you want full control over your API documentation interface.

Example: Custom Documentation Page

from fastapi import FastAPI
from fastapi.responses import HTMLResponse

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

@app.get("/")
def root():
    return {"message": "FastAPI APP"}

@app.get("/docs", include_in_schema=False, response_class=HTMLResponse)
def custom_docs():
    return """
<!DOCTYPE html>
<html>
<head>
    <title>FastAPI Custom Docs</title>
</head>
<body>
    <h1>FastAPI Custom Docs</h1>
    <p>This is a simple custom documentation page.</p>
</body>
</html>
"""

How it works

• The /docs endpoint now returns HTML instead of JSON.
• response_class=HTMLResponse tells FastAPI to render the response as HTML.
• include_in_schema=False hides this route from the autogenerated API documentation.
• Setting docs_url=None disables the default Swagger UI.

Result

When you visit:

/docs

you will see your custom HTML documentation page instead of the default FastAPI Swagger interface.

From here, you can fully customize the page with:

1. CSS styling
2. JavaScript interactivity
3. Branding and logos
4. Links to API guides or SDKs

Conclusion

FastAPI gives you a powerful starting point with automatic documentation, but its real strength is flexibility. You can either use the built-in tools or completely replace them with your own custom developer experience.

If you’re building production-grade APIs, especially something like wallet infrastructure or developer tools, custom documentation is not just a nice-to-have feature — it’s a competitive advantage.