FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.7+ based on standard Python type hints. It has rapidly become one of the most popular choices for Python developers when building RESTful APIs and microservices.
Table of contents
Open Table of contents
What is FastAPI?
FastAPI is a modern web framework created by Sebastián Ramirez that combines the best features of existing Python frameworks while leveraging modern Python features like type hints and async/await. It’s designed to be easy to use, fast to code, and production-ready.
Key Features
Automatic API Documentation
FastAPI automatically generates interactive API documentation using OpenAPI (formerly Swagger) and provides both Swagger UI and ReDoc interfaces out of the box.
Type Safety with Python Type Hints
Built-in support for Python type hints provides automatic request validation, serialization, and documentation generation.
High Performance
One of the fastest Python frameworks available, comparable to NodeJS and Go, thanks to Starlette for the web parts and Pydantic for the data parts.
Async Support
Full support for asynchronous programming with async/await syntax for handling concurrent requests efficiently.
Data Validation
Automatic request and response validation using Pydantic models, reducing boilerplate code and ensuring data integrity.
Why Choose FastAPI?
- Developer Experience: Excellent editor support with autocompletion and type checking
- Standards-based: Built on open standards like OpenAPI and JSON Schema
- Production Ready: Used by companies like Microsoft, Netflix, and Uber
- Easy Testing: Simple to write tests with pytest
- Flexible: Can be used for both simple APIs and complex applications
Getting Started with FastAPI
To get started with FastAPI, install it using pip:
pip install fastapi[all]
The [all] option includes all optional dependencies. For a minimal installation, use:
pip install fastapi uvicorn
Building Your First API
Let’s create a simple FastAPI application:
from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional
# Create FastAPI instance
app = FastAPI(title="My First API", version="1.0.0")
# Pydantic model for request/response
class Item(BaseModel):
name: str
description: Optional[str] = None
price: float
tax: Optional[float] = None
# Root endpoint
@app.get("/")
async def read_root():
return {"message": "Welcome to FastAPI!"}
# GET endpoint with path parameter
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: Optional[str] = None):
return {"item_id": item_id, "q": q}
# POST endpoint with request body
@app.post("/items/")
async def create_item(item: Item):
return {"item": item, "message": "Item created successfully"}
# PUT endpoint for updating items
@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
return {"item_id": item_id, "item": item}
Run the application with:
uvicorn main:app --reload
Your API will be available at http://localhost:8000, with automatic documentation at http://localhost:8000/docs.
Advanced Features
Dependency Injection
FastAPI provides a powerful dependency injection system:
from fastapi import Depends, HTTPException
def get_db():
# Database connection logic
db = connect_to_database()
try:
yield db
finally:
db.close()
@app.get("/users/{user_id}")
async def get_user(user_id: int, db = Depends(get_db)):
user = db.get_user(user_id)
if not user:
raise HTTPException(status_code=404, detail="User not found")
return user
Authentication and Security
Built-in support for various authentication methods:
from fastapi import Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
security = HTTPBearer()
async def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
token = credentials.credentials
# Token verification logic here
if not verify_jwt_token(token):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid token",
headers={"WWW-Authenticate": "Bearer"},
)
return token
@app.get("/protected")
async def protected_route(token: str = Depends(verify_token)):
return {"message": "This is a protected route", "token": token}
Background Tasks
Execute tasks in the background without blocking the response:
from fastapi import BackgroundTasks
def send_notification(email: str, message: str):
# Send notification logic
print(f"Sending notification to {email}: {message}")
@app.post("/send-notification/")
async def send_notification_endpoint(
email: str,
background_tasks: BackgroundTasks
):
background_tasks.add_task(send_notification, email, "Welcome!")
return {"message": "Notification sent in background"}
Middleware and CORS
Add middleware for cross-cutting concerns:
from fastapi.middleware.cors import CORSMiddleware
from fastapi.middleware.gzip import GZipMiddleware
app.add_middleware(GZipMiddleware, minimum_size=1000)
app.add_middleware(
CORSMiddleware,
allow_origins=["https://mywebsite.com"],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
Performance and Benchmarks
FastAPI consistently ranks among the top Python web frameworks for performance:
- High throughput: Capable of handling thousands of requests per second
- Low latency: Minimal overhead thanks to async support and efficient routing
- Memory efficient: Optimized memory usage compared to traditional frameworks
Best Practices
Project Structure
my_fastapi_app/
├── app/
│ ├── __init__.py
│ ├── main.py
│ ├── dependencies.py
│ ├── routers/
│ │ ├── __init__.py
│ │ ├── items.py
│ │ └── users.py
│ ├── models/
│ │ ├── __init__.py
│ │ └── item.py
│ └── core/
│ ├── __init__.py
│ └── config.py
├── tests/
│ ├── __init__.py
│ └── test_main.py
└── requirements.txt
Error Handling
from fastapi import HTTPException
from fastapi.responses import JSONResponse
@app.exception_handler(ValueError)
async def value_error_handler(request, exc):
return JSONResponse(
status_code=400,
content={"message": f"Invalid value: {str(exc)}"}
)
Environment Configuration
from pydantic import BaseSettings
class Settings(BaseSettings):
app_name: str = "Awesome API"
admin_email: str
items_per_user: int = 50
class Config:
env_file = ".env"
settings = Settings()
Testing Your FastAPI Application
FastAPI makes testing straightforward with the built-in test client:
from fastapi.testclient import TestClient
from main import app
client = TestClient(app)
def test_read_main():
response = client.get("/")
assert response.status_code == 200
assert response.json() == {"message": "Welcome to FastAPI!"}
def test_create_item():
response = client.post(
"/items/",
json={"name": "Test Item", "price": 10.5}
)
assert response.status_code == 200
assert response.json()["item"]["name"] == "Test Item"
Conclusion
FastAPI represents a significant evolution in Python web development, combining modern Python features with excellent performance and developer experience. Its automatic documentation generation, type safety, and async support make it an excellent choice for building robust APIs.
Whether you’re building a simple REST API, a complex microservice, or a full-scale web application, FastAPI provides the tools and performance you need. Its growing ecosystem and active community ensure that it will continue to be a leading choice for Python web development.
The framework’s emphasis on standards, type safety, and developer productivity makes it particularly well-suited for modern application development where API-first approaches and microservices architectures are becoming the norm. By leveraging FastAPI, developers can build high-quality, maintainable, and performant applications with significantly less boilerplate code than traditional frameworks.