Framework · Since 2018

FastAPI

FastAPI is a high-performance Python web framework for building APIs, using type hints to drive validation, serialization and automatic API docs.

Start the guide Discussions

FastAPI is a modern framework for building web APIs in Python. Sebastián Ramírez first released it in 2018, and it is developed in the open with a large community of contributors. It builds on Starlette for the web layer and Pydantic for data validation, so the type hints on your function parameters are enough to parse and validate requests, serialize responses and generate an OpenAPI description of your API.

FastAPI is a natural fit wherever input validation and documentation matter: REST backends, microservices, machine learning model serving and internal tools. Because it runs on ASGI, async endpoints can handle many concurrent connections efficiently, while plain def functions keep working too. Its dependency injection system lets you factor out database sessions, authentication and settings, and swap them out cleanly in tests.

To get started, create a virtual environment, install it with pip install "fastapi[standard]", run fastapi dev main.py and open /docs to call your endpoints from the interactive documentation. The official Tutorial - User Guide walks step by step from path parameters through security, databases and testing, and is designed to be read in order. Once you are comfortable with Python type hints and Pydantic models, most of FastAPI follows naturally.

Highlights

Validation from type hints

Parameter types and Pydantic models are all FastAPI needs to convert and validate request data, returning detailed errors for invalid input.

Automatic API docs

An OpenAPI schema is generated from your code and served as interactive documentation at /docs (Swagger UI) and /redoc.

Dependency injection

Declare database sessions, authentication or shared parameters with Depends; FastAPI resolves them per request and lets tests override them.

Async support and high performance

Built on Starlette and ASGI, async def endpoints handle many concurrent connections efficiently, and regular def functions work alongside them.

Where it is used

REST APIs and backend services
Microservices
Serving machine learning models over HTTP
Internal tools and admin backends

Install

1
Create a virtual environment
Create and activate a Python virtual environment in your project folder. The command below is for macOS and Linux; on Windows, activate it with .venv\Scripts\activate.
```
python -m venv .venv && source .venv/bin/activate
```
2
Install FastAPI
Install FastAPI with the standard extras, which bring in commonly used dependencies such as the Uvicorn server and the fastapi command-line tool.
```
pip install "fastapi[standard]"
```
3
Run the development server
Create main.py and start the development server. It reloads automatically when you change code, and http://127.0.0.1:8000/docs shows the interactive API documentation.
```
fastapi dev main.py
```

Your first program

Your first project

FastAPI() creates the application, and the @app.get decorator binds a path and HTTP method to a function. The dictionary the function returns becomes a JSON response. In the second endpoint, item_id: int converts and validates the path value as an integer, while q, which has a default, becomes an optional query parameter. Run fastapi dev main.py and try both endpoints from /docs.

main.py

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 = None):
    return {"item_id": item_id, "q": q}

pip install "fastapi[standard]"
fastapi dev main.py

Everyday tools

Uvicorn: The ASGI server that runs FastAPI applications. The fastapi dev and fastapi run commands use it under the hood.
Pydantic: A library for defining, validating and serializing data models with type hints, used for request bodies, response models and settings.
SQLModel: A library by FastAPI's author that combines SQLAlchemy and Pydantic, so one class can define both a database table and an API model.
pytest: Python's most widely used testing tool. Paired with FastAPI's TestClient, it tests your API without starting a server.

Step-by-step guide

Six chapters that take you from installation to the core ideas of FastAPI.

Official docs and resources

Languages

PythonPython is a readable, general-purpose language with a large standard library, widely used for automation, web backends, data analysis and machine learning.

Discussions

Start a discussion

Ask questions, share experience and trade opinions about FastAPI.

No discussions yet. Start the first one.