FastAPI ORG

FastAPI framework, high performance, easy to learn, fast to code, ready for production

---

Documentation: https://fastapi.tiangolo.com

Source Code: https://github.com/fastapi/fastapi

---

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints.

The key features are:

• Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
• Fast to code: Increase the speed to develop features by about 200% to 300%. *
• Fewer bugs: Reduce about 40% of human (developer) induced errors. *
• Intuitive: Great editor support. Completion everywhere. Less time debugging.
• Easy: Designed to be easy to use and learn. Less time reading docs.
• Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
• Robust: Get production-ready code. With automatic interactive documentation.
• Standards-based: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.

• estimation based on tests conducted by an internal development team, building production applications.

Sponsors

<!-- sponsors -->

Keystone Sponsor

Gold Sponsors

Silver Sponsors

<!-- /sponsors -->

Other sponsors

Opinions

"_[...] I'm using FastAPI a ton these days. [...] I'm actually planning to use it for all of my team's ML services at Microsoft. Some of them are getting integrated into the core Windows product and some Office products._"

Kabir Khan - Microsoft (ref)

---

"_We adopted the FastAPI library to spawn a REST server that can be queried to obtain predictions. [for Ludwig]_"

Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - Uber (ref)

---

"_Netflix is pleased to announce the open-source release of our crisis management orchestration framework: Dispatch! [built with FastAPI]_"

Kevin Glisson, Marc Vilanova, Forest Monsen - Netflix (ref)

---

"_If anyone is looking to build a production Python API, I would highly recommend FastAPI. It is beautifully designed, simple to use and highly scalable, it has become a key component in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer._"

Deon Pillsbury - Cisco (ref)

---

FastAPI Conf

FastAPI Conf '26 is happening on October 28, 2026 in Amsterdam, NL. All about FastAPI, right from the source. 🎤

FastAPI mini documentary

There's a FastAPI mini documentary released at the end of 2025, you can watch it online:

Typer, the FastAPI of CLIs

If you are building a CLI app to be used in the terminal instead of a web API, check out Typer.

Typer is FastAPI's little sibling. And it's intended to be the FastAPI of CLIs. ⌨️ 🚀

Requirements

FastAPI stands on the shoulders of giants:

• Starlette for the web parts.
• Pydantic for the data parts.

Installation

Create and activate a virtual environment and then install FastAPI:

console
$ pip install "fastapi[standard]"

---> 100%

Note: Make sure you put "fastapi[standard]" in quotes to ensure it works in all terminals.

Example

Create it

Create a file main.py with:

Python
from fastapi import FastAPI

app = FastAPI()


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


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

Or use async def...

If your code uses async / await, use async def:

Python hl_lines="7  12"
from fastapi import FastAPI

app = FastAPI()


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


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

Note:

If you don't know, check the _"In a hurry?"_ section about async and await in the docs.

Run it

Run the server with:

console
$ fastapi dev

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │
 │  Running in development mode, for production use:   │
 │                                                     │
 │  fastapi run                                        │
 │                                                     │
 ╰─────────────────────────────────────────────────────╯

INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2248755] using WatchFiles
INFO:     Started server process [2248757]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

About the command fastapi dev...

The command fastapi dev reads your main.py file automatically, detects the FastAPI app in it, and starts a server using Uvicorn.

By default, fastapi dev will start with auto-reload enabled for local development.

You can read more about it in the FastAPI CLI docs.

Check it

Open your browser at http://127.0.0.1:8000/items/5?q=somequery.

You will see the JSON response as:

JSON
{"item_id": 5, "q": "somequery"}

You already created an API that:

• Receives HTTP requests in the _paths_ / and /items/{item_id}.
• Both _paths_ take GET operations (also known as HTTP _methods_).
• The _path_ /items/{item_id} has a _path parameter_ item_id that should be an int.
• The _path_ /items/{item_id} has an optional str _query parameter_ q.

Interactive API docs

Now go to http://127.0.0.1:8000/docs.

You will see the automatic interactive API documentation (provided by Swagger UI):

!Swagger UI

Alternative API docs

And now, go to http://127.0.0.1:8000/redoc.

You will see the alternative automatic documentation (provided by ReDoc):

!ReDoc

Example upgrade

Now modify the file main.py to receive a body from a PUT request.

Declare the body using standard Python types, thanks to Pydantic.

Python hl_lines="2  7-10 23-25"
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


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


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


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


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

The fastapi dev server should reload automatically.

Interactive API docs upgrade

Now go to http://127.0.0.1:8000/docs.

• The interactive API documentation will be automatically updated, including the new body:

!Swagger UI

• Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:

!Swagger UI interaction

• Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:

!Swagger UI interaction

Alternative API docs upgrade

And now, go to http://127.0.0.1:8000/redoc.

• The alternative documentation will also reflect the new query parameter and body:

!ReDoc

Recap

In summary, you declare once the types of parameters, body, etc. as function parameters.

You do that with standard modern Python types.

You don't have to learn a new syntax, the methods or classes of a specific library, etc.

Just standard Python.

For example, for an int:

Python
item_id: int

or for a more complex Item model:

Python
item: Item

...and with that single declaration you get:

• Editor support, including:

* Completion. * Type checks.

• Validation of data:

* Automatic and clear errors when the data is invalid. * Validation even for deeply nested JSON objects.

• Conversion of input data: coming from the network to Python data and types. Reading from:

* JSON. * Path parameters. * Query parameters. * Cookies. * Headers. * Forms. * Files.

• Conversion of output data: converting from Python data and types to network data (as JSON):

* Convert Python types (str, int, float, bool, list, etc). * datetime objects. * UUID objects. * Database models. * ...and many more.

• Automatic interactive API documentation, including 2 alternative user interfaces:

* Swagger UI. * ReDoc.

---

Coming back to the previous c

…

Collapse