FastAPI Cheat Sheet

Updated 2026-04-24

Next Topic: Fastify Node.js Framework Cheat Sheet

FastAPI is a modern, high-performance Python web framework for building APIs based on standard Python type hints. It's built on top of Starlette for web handling and Pydantic for data validation, providing automatic API documentation, async support, and excellent developer experience. FastAPI excels at creating production-ready RESTful APIs quickly while maintaining type safety and performance. One key distinction: FastAPI's automatic validation and documentation generation from type hints eliminates boilerplate code that other frameworks require manually, making it both fast to develop with and fast to execute.

Quick Index155 entries · 19 tables

Mind Map

19 tables, 155 concepts. Select a concept node to jump to its table row.

Preparing mind map...

Table 1: Core Application Setup

Concept	Example	Description
FastAPI app instance	`app = FastAPI()` `app = FastAPI(title="My API", version="1.0.0")`	• Creates the main application instance • accepts optional metadata like title, description, version for OpenAPI docs.
Path operation decorator	`@app.get("/")` `@app.post("/items")`	• Defines an HTTP endpoint with method and path • decorator tells FastAPI to handle requests to this route.
Path operation function	`def read_root():` `return {"msg": "Hello"}`	• Function executed when endpoint is hit • return value is automatically serialized to JSON.
Run with FastAPI CLI	`fastapi dev main.py` `fastapi run main.py`	• Recommended way to run FastAPI (included in `fastapi[standard]`) • `dev` for development (auto-reload, localhost only); `run` for production (no reload, 0.0.0.0).
Run with Uvicorn	`uvicorn main:app --reload`	• Starts the ASGI server directly; preferred for containerized or programmatic use • `fastapi dev`/`fastapi run` are now the recommended alternatives.
Async path operation	`async def read_items():` `return await db.fetch()`	• Uses `async def` for non-blocking I/O operations • better performance for I/O-bound tasks.
Lifespan context manager	`from contextlib import asynccontextmanager` `@asynccontextmanager` `async def lifespan(app):` `# startup` `yield` `# shutdown` `app = FastAPI(lifespan=lifespan)`	• Manages startup and shutdown logic • replaces deprecated `on_event` decorators with single context manager.
Automatic documentation	`/docs` for Swagger UI `/redoc` for ReDoc	• FastAPI auto-generates interactive API docs at these endpoints based on your code • requires zero configuration.
Pydantic integration	`class Item(BaseModel):` `name: str` `price: float`	• Pydantic models provide automatic validation and serialization • FastAPI uses them for request/response schemas.

Table 2: HTTP Methods and Route Definitions

Method	Example	Description
GET request	`@app.get("/items/{id}")` `def read_item(id: int):`	• Retrieves data • no request body, typically uses path or query parameters.
POST request	`@app.post("/items")` `def create_item(item: Item):`	• Creates new resource • accepts request body defined by Pydantic model.
PUT request	`@app.put("/items/{id}")` `def update_item(id: int, item: Item):`	• Replaces entire resource • expects complete object in request body.
PATCH request	`@app.patch("/items/{id}")` `def partial_update(id: int, item: PartialItem):`	• Updates partial resource • only specified fields are modified.
DELETE request	`@app.delete("/items/{id}")` `def delete_item(id: int):`	• Removes resource • typically returns status confirmation.
HEAD request	`@app.head("/items")` `def items_head():`	• Returns headers only, no body • useful for checking resource existence or metadata.
OPTIONS request	`@app.options("/items")` `def items_options():`	• Returns allowed HTTP methods for endpoint • often handled automatically for CORS.

Table 3: Request Parameters

Type	Example	Description
Annotated parameter syntax	`from typing import Annotated` `q: Annotated[str \| None, Query(max_length=50)] = None`	• Recommended modern syntax (since FastAPI 0.95.0) for declaring parameters with validation • keeps type annotation and metadata together.
Path parameter	`@app.get("/items/{item_id}")` `def read(item_id: int):`	• Extracts value from URL path • type validated automatically based on annotation.
Query parameter	`def read_items(skip: int = 0, limit: int = 10):`	• Reads from URL query string (`?skip=0&limit=10`) • optional with defaults.
Request body	`def create(item: Item):`	• Accepts JSON payload • Pydantic model validates structure and types automatically.
Multiple body parameters	`def create(item: Item, user: User):`	• Accepts multiple JSON objects in request body • FastAPI expects nested structure.
Header parameter	`from fastapi import Header` `def read(user_agent: str = Header()):`	• Reads HTTP headers • automatically converts hyphen-case to snake_case.
Cookie parameter	`from fastapi import Cookie` `def read(session_id: str = Cookie()):`	• Extracts cookie values • type-validated like other parameters.
Form data	`from fastapi import Form` `def login(username: str = Form()):`	• Accepts `application/x-www-form-urlencoded` • requires python-multipart installed.
File upload	`from fastapi import UploadFile` `def upload(file: UploadFile):`	• Handles file uploads • `UploadFile` provides async methods and metadata like filename.
Multiple file upload	`def upload(files: list[UploadFile]):`	• Accepts multiple files in single request • validated as list.

Table 4: Parameter Validation

Technique	Example	Description
Annotated query validation	`from typing import Annotated` `q: Annotated[str \| None, Query(min_length=3)] = None`	• Recommended way to use Query, Path, Header, Cookie • type annotation and validation rules stay together.
Query validation	`from fastapi import Query` `q: str = Query(min_length=3)`	Applies constraints like min/max length, regex patterns to query parameters.
Path validation	`from fastapi import Path` `id: int = Path(ge=1, le=1000)`	Validates path parameters with numeric constraints like ge (greater/equal), le (less/equal).
Required query parameter	`q: Annotated[str, Query(min_length=1)]`	• Modern approach: no default = required when using Annotated • older approach: `q: str = Query(...)` with ellipsis.
Optional with None	`q: str \| None = None`	• Python 3.10+ union syntax for optional parameters • older versions use `Optional[str]`.
List query parameter	`tags: list[str] = Query([])`	• Accepts multiple values for same parameter (`?tags=a&tags=b`) • validated as list.
Alias parameter	`item_query: str = Query(alias="item-query")`	Maps hyphenated URL param to snake_case Python variable.
Deprecated parameter	`old_param: str = Query(deprecated=True)`	• Marks parameter as deprecated in OpenAPI docs • still functional but discouraged.
Regex validation	`code: str = Query(pattern="^[A-Z]{3}$")`	Validates string parameter against regex pattern.
Numeric constraints	`price: float = Query(gt=0, le=9999.99)`	Applies gt (greater than), lt (less than), ge, le constraints to numbers.

Table 5: Pydantic Models and Validation

Concept	Example	Description
BaseModel	`class Item(BaseModel):` `name: str` `price: float`	• Base class for all Pydantic models • provides automatic validation and serialization.
Field constraints	`from pydantic import Field` `price: float = Field(gt=0)`	• Adds validation rules directly to model fields • similar to Query/Path but for models.
Field description	`name: str = Field(description="Item name")`	• Adds documentation to field • appears in OpenAPI schema.
Field example	`price: float = Field(examples=[9.99, 19.99])`	Provides example values for API documentation and testing.
Field validator	`@field_validator('email')` `def check_email(cls, v):`	• Custom validation logic for specific field • runs after type validation.
Model validator	`@model_validator(mode='after')` `def check_passwords(self):`	• Validates entire model after individual fields • useful for cross-field validation.
model_config	`from pydantic import ConfigDict` `model_config = ConfigDict(str_strip_whitespace=True)`	• Configures model behavior using Pydantic v2's `ConfigDict` • replaces the old inner `class Config`.
Optional fields	`description: str \| None = None`	• Field can be omitted or null • uses Python union type or `Optional`.
Computed field	`@computed_field` `@property` `def total(self) -> float:`	• Adds calculated field to model • included in serialization but not validation.
Model inheritance	`class ExtendedItem(Item):` `category: str`	• Inherits fields from base model • enables model reuse and extension.

Table 6: Response Configuration

Technique	Example	Description
Response model	`@app.post("/items", response_model=Item)`	• Specifies return type for validation and docs • filters response to match model.
Return type annotation	`async def create_item(item: Item) -> Item:`	• Modern preferred approach for response type declaration • FastAPI uses the return annotation for validation, filtering, and docs.
Response model exclude	`response_model=User, response_model_exclude={"password"}`	• Removes specified fields from response • useful for hiding sensitive data.
Status code	`@app.post("/items", status_code=201)`	• Sets HTTP status code for response • default is 200 for GET, 201 for POST recommended.
JSONResponse	`from fastapi.responses import JSONResponse` `return JSONResponse(content=data)`	Explicit JSON response with custom headers or status code.
HTMLResponse	`from fastapi.responses import HTMLResponse` `return HTMLResponse(content=html)`	• Returns HTML content • sets Content-Type to text/html.
RedirectResponse	`from fastapi.responses import RedirectResponse` `return RedirectResponse(url="/new")`	• HTTP redirect to different URL • status_code defaults to 307.
FileResponse	`from fastapi.responses import FileResponse` `return FileResponse(path="file.pdf")`	• Serves static files • handles content-type and download headers automatically.
StreamingResponse	`from fastapi.responses import StreamingResponse` `return StreamingResponse(generator)`	• Streams large data in chunks • memory-efficient for big responses.
ORJSONResponse	`from fastapi.responses import ORJSONResponse` `return ORJSONResponse(content=data)`	• Uses faster orjson library for JSON serialization • 2-3x performance improvement.
Response headers	`from fastapi import Response` `response.headers["X-Custom"] = "value"`	Sets custom HTTP headers in response.
Set cookies	`response.set_cookie(key="session", value="abc")`	• Adds cookie to response • supports httponly, secure, samesite options.

Table 7: Dependency Injection

Pattern	Example	Description
Basic dependency	`from typing import Annotated` `def route(db: Annotated[DB, Depends(get_db)]):`	• Function providing reusable logic • recommended Annotated syntax (since 0.95.0) keeps type and dependency together.
Annotated type alias dependency	`DBDep = Annotated[Session, Depends(get_db)]` `def endpoint(db: DBDep):`	• Defines reusable type alias for common dependency • reduces repetition across many routes.
Async dependency	`async def get_session():` `async with Session() as s:` `yield s`	• Async generator dependency • cleanup happens after response using `yield`.
Class dependency	`class Pagination:` `def __init__(self, skip=0):`	• Class instances as dependencies • `__init__` parameters become sub-dependencies.
Nested dependencies	`def get_user(token = Depends(get_token)):`	• Dependency can depend on other dependencies • creates dependency chain.
Global dependencies	`app = FastAPI(dependencies=[Depends(verify)])`	• Applied to all routes in application • useful for auth, logging.
Router dependencies	`router = APIRouter(dependencies=[Depends(check)])`	• Applied to all routes in router • scoped to specific module.
Yield dependency	`def get_db():` `db = Database()` `yield db` `db.close()`	• Provides resource cleanup after request • code after yield runs as teardown.
Dependency override	`app.dependency_overrides[get_db] = mock_db`	• Replaces dependency for testing • allows mocking without changing code.
Dependencies in path decorator	`@app.get("/items", dependencies=[Depends(verify)])`	• Dependency executed but result not used in function • for side effects only.

Table 8: Error Handling

Approach	Example	Description
HTTPException	`from fastapi import HTTPException` `raise HTTPException(status_code=404, detail="Not found")`	• Built-in exception for HTTP errors • automatically formatted as JSON response.
Custom exception	`class CustomError(Exception):` `pass`	• Define custom exception class • can add custom handler.
Exception handler	`@app.exception_handler(CustomError)` `def handler(request, exc):`	• Catches specific exception type globally • returns custom response.
Validation error handler	`from fastapi.exceptions import RequestValidationError` `@app.exception_handler(RequestValidationError)`	Customizes Pydantic validation error response format.
Status code in exception	`raise HTTPException(status_code=403, detail="Forbidden")`	• Sets HTTP status code directly in exception • common codes: 400, 401, 403, 404, 500.
Custom headers in exception	`raise HTTPException(status_code=401, headers={"WWW-Authenticate": "Bearer"})`	• Adds custom headers to error response • useful for auth challenges.
Override default handlers	`from starlette.exceptions import HTTPException as StarletteHTTPException` `@app.exception_handler(StarletteHTTPException)`	Replaces FastAPI's default error formatting.

Table 9: Authentication and Security

Mechanism	Example	Description
OAuth2 password flow	`from fastapi.security import OAuth2PasswordBearer` `oauth2 = OAuth2PasswordBearer(tokenUrl="token")`	• Standard OAuth2 flow for password-based authentication • extracts token from Authorization header.
OAuth2 password request	`from fastapi.security import OAuth2PasswordRequestForm` `def login(form: OAuth2PasswordRequestForm = Depends()):`	• Form data model for username/password login • includes username, password, optional scope.
API key in header	`from fastapi.security import APIKeyHeader` `api_key = APIKeyHeader(name="X-API-Key")`	• Extracts API key from custom header • name specifies header name.
API key in query	`from fastapi.security import APIKeyQuery` `api_key = APIKeyQuery(name="api_key")`	• Reads API key from query parameter • less secure than header.
API key in cookie	`from fastapi.security import APIKeyCookie` `api_key = APIKeyCookie(name="session")`	Extracts API key from cookie.
JWT token creation	`from jose import jwt` `token = jwt.encode(data, SECRET, algorithm="HS256")`	• Encodes JWT token with payload and secret • requires python-jose library.
JWT token verification	`from jose import JWTError, jwt` `payload = jwt.decode(token, SECRET, algorithms=["HS256"])`	• Decodes and verifies JWT • raises JWTError if invalid.
Password hashing	`from passlib.context import CryptContext` `pwd_context = CryptContext(schemes=["bcrypt"])`	• Hashes passwords with bcrypt • never store plain passwords.
Current user dependency	`async def get_current_user(token = Depends(oauth2)):` `# decode token, fetch user`	• Dependency that extracts and validates user from token • reusable across routes.
Security scopes	`@app.get("/items", dependencies=[Depends(has_scope("read:items"))])`	• Permission-based access control • validates OAuth2 scopes.

Table 10: Middleware

Type	Example	Description
CORS middleware	`from fastapi.middleware.cors import CORSMiddleware` `app.add_middleware(CORSMiddleware, allow_origins=["*"])`	• Enables Cross-Origin Resource Sharing • configures which domains can access API.
Custom function middleware	`@app.middleware("http")` `async def add_header(request, call_next):`	• Function-based middleware • runs before and after every request.
Custom class middleware	`class TimingMiddleware(BaseHTTPMiddleware):` `async def dispatch(self, request, call_next):`	• Class-based middleware • more complex logic, state management.
Trusted host middleware	`from starlette.middleware.trustedhost import TrustedHostMiddleware` `app.add_middleware(TrustedHostMiddleware, allowed_hosts=["*.example.com"])`	• Validates Host header • prevents HTTP Host header attacks.
HTTPS redirect middleware	`from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware` `app.add_middleware(HTTPSRedirectMiddleware)`	• Redirects HTTP to HTTPS • enforces secure connections.
GZip middleware	`from fastapi.middleware.gzip import GZipMiddleware` `app.add_middleware(GZipMiddleware, minimum_size=1000)`	• Compresses responses over specified size • reduces bandwidth.
Session middleware	`from starlette.middleware.sessions import SessionMiddleware` `app.add_middleware(SessionMiddleware, secret_key="key")`	Adds session support via signed cookies.

Table 11: Background Tasks

Approach	Example	Description
BackgroundTasks	`from fastapi import BackgroundTasks` `def task(email: str):` `send_email(email)`	• Simple background function executed after response • no external queue needed.
Add background task	`def endpoint(bg: BackgroundTasks):` `bg.add_task(send_email, to="user@example.com")`	• Schedules function to run after response sent • tasks run in same process.
Multiple background tasks	`bg.add_task(task1)` `bg.add_task(task2)`	Multiple tasks run sequentially in order added.
Background task with dependencies	`def task(db = Depends(get_db)):`	• Background task can use dependency injection • dependencies resolved when task runs.
Celery integration	`from celery import Celery` `celery = Celery("tasks", broker="redis://localhost")` `@celery.task` `def heavy_task():`	• Distributed task queue for heavy/long-running jobs • runs in separate workers outside request cycle.
ARQ for async tasks	`from arq import create_pool` `redis = await create_pool()`	• Redis-based async task queue • alternative to Celery for async-first applications.

Table 12: Database Integration

Technique	Example	Description
SQLAlchemy async session	`from sqlalchemy.ext.asyncio import AsyncSession` `async def get_db():` `yield session`	• Async database session for non-blocking DB operations • requires async driver.
SQLAlchemy sync session	`from sqlalchemy.orm import Session` `def get_db():` `yield db`	• Synchronous session • simpler but blocks during queries.
Database model	`from sqlalchemy import Column, Integer, String` `class User(Base):` `id = Column(Integer, primary_key=True)`	• ORM model defining table structure • SQLAlchemy maps to database tables.
Async database query	`result = await session.execute(select(User))` `users = result.scalars().all()`	• Executes async query • uses SQLAlchemy 2.0 style.
Database dependency	`def endpoint(db: Session = Depends(get_db)):`	• Injects database session into route • session closed automatically after request.
Alembic migrations	`alembic init alembic` `alembic revision --autogenerate` `alembic upgrade head`	• Database schema migrations • tracks and applies schema changes over time.
Connection pooling	`engine = create_async_engine(url, pool_size=20, max_overflow=10)`	• Reuses database connections • critical for production performance.

Table 13: WebSockets and Real-Time Communication

Feature	Example	Description
WebSocket endpoint	`from fastapi import WebSocket` `@app.websocket("/ws")` `async def websocket_endpoint(websocket: WebSocket):`	• Defines WebSocket route • full-duplex communication channel.
Accept connection	`await websocket.accept()`	• Establishes WebSocket connection • must be called before send/receive.
Receive message	`data = await websocket.receive_text()` `data = await websocket.receive_json()`	• Reads message from client • supports text, JSON, or bytes.
Send message	`await websocket.send_text("Hello")` `await websocket.send_json({"msg": "Hi"})`	Sends message to client.
WebSocket disconnect	`try:` `while True:` `await websocket.receive_text()` `except WebSocketDisconnect:`	• Handles client disconnect • exception raised when connection closes.
Server-Sent Events	`from fastapi.responses import StreamingResponse` `def event_stream():` `yield f"data: {msg}\n\n"`	• One-way streaming from server to client • simpler than WebSockets for uni-directional updates.

Table 14: Testing

Tool	Example	Description
TestClient	`from fastapi.testclient import TestClient` `client = TestClient(app)` `response = client.get("/")`	• Synchronous test client • tests FastAPI without running server.
Test with pytest	`def test_read_main():` `response = client.get("/")` `assert response.status_code == 200`	• Standard pytest patterns work with TestClient • uses fixtures for setup.
TestClient as context manager	`with TestClient(app) as client:` `response = client.get("/")`	• Triggers lifespan events during testing • startup/shutdown run automatically.
Async test client	`from httpx import AsyncClient` `async with AsyncClient(app=app) as client:` `response = await client.get("/")`	• Async testing with httpx • required for testing async dependencies properly.
Override dependency	`app.dependency_overrides[get_db] = lambda: mock_db`	• Replaces real dependency with mock for testing • no code changes needed.
Test file upload	`files = {"file": ("test.txt", b"content", "text/plain")}` `client.post("/upload", files=files)`	• Simulates file upload in tests • tuple format: (filename, content, content-type).
Test with pytest fixtures	`@pytest.fixture` `def client():` `return TestClient(app)`	• Reusable test setup • pytest fixture creates client for all tests.

Table 15: Advanced Routing

Concept	Example	Description
APIRouter	`from fastapi import APIRouter` `router = APIRouter(prefix="/items", tags=["items"])`	• Modular routing • groups related endpoints with shared prefix and tags.
Include router	`app.include_router(router)`	• Mounts router to main app • enables splitting large apps into modules.
Sub-application mounting	`app.mount("/v1", app_v1)`	• Mounts independent FastAPI app at path • useful for API versioning.
Static files	`from fastapi.staticfiles import StaticFiles` `app.mount("/static", StaticFiles(directory="static"))`	Serves static files from directory.
Router dependencies	`router = APIRouter(dependencies=[Depends(verify_token)])`	• Applies dependency to all routes in router • cleaner than per-route.
Router tags	`router = APIRouter(tags=["items"])`	• Groups endpoints in OpenAPI docs • creates collapsible sections.
Route priority	Define more specific routes first: `@app.get("/users/me")` `@app.get("/users/{id}")`	• FastAPI matches first matching route • specific paths before parameterized ones.

Table 16: OpenAPI Customization

Element	Example	Description
Metadata	`app = FastAPI(title="My API", description="Docs", version="1.0")`	Sets API title, description, version in OpenAPI schema and docs.
Tags metadata	`tags_metadata = [{"name": "items", "description": "Item operations"}]` `app = FastAPI(openapi_tags=tags_metadata)`	Adds descriptions to tag groups in documentation.
Custom OpenAPI schema	`def custom_openapi():` `# modify schema` `app.openapi = custom_openapi`	• Overrides OpenAPI generation • add custom extensions or modify schema.
Disable docs	`app = FastAPI(docs_url=None, redoc_url=None)`	• Hides documentation endpoints • use in production if needed.
Custom docs URL	`app = FastAPI(docs_url="/api/docs")`	Changes Swagger UI path from default `/docs`.
Operation ID	`@app.get("/items", operation_id="get_all_items")`	• Sets unique operation identifier in OpenAPI • useful for code generation tools.
Deprecate endpoint	`@app.get("/old", deprecated=True)`	• Marks endpoint as deprecated in docs • still functional.
Response examples	`responses={200: {"description": "OK", "content": {"application/json": {"example": {...}}}}}`	Adds example responses to OpenAPI docs.
Separate input/output schemas	`app = FastAPI(separate_input_output_schemas=False)`	• FastAPI 0.102.0+ generates separate OpenAPI schemas for input and output with Pydantic v2 • set `False` to disable.
Configure Swagger UI	`app = FastAPI(swagger_ui_parameters={"defaultModelsExpandDepth": -1})`	Customizes Swagger UI behavior like theme, syntax highlighting, model expansion.

Table 17: Settings and Configuration

Technique	Example	Description
Pydantic Settings	`from pydantic_settings import BaseSettings` `class Settings(BaseSettings):` `api_key: str`	• Type-safe configuration from environment variables • validates config at startup.
Read .env file	`from pydantic_settings import SettingsConfigDict` `model_config = SettingsConfigDict(env_file=".env")`	• Loads environment variables from .env using Pydantic Settings v2 • replaces old inner `class Config: env_file = ".env"` pattern.
Settings dependency	`def get_settings():` `return Settings()` `settings: Settings = Depends(get_settings)`	• Injects settings into routes • enables easy mocking in tests.
Cached settings	`@lru_cache` `def get_settings():` `return Settings()`	• Loads settings once and caches • improves performance.
Multiple environments	`class Settings(BaseSettings):` `env: str = "dev"` `database_url: str`	• Uses different config per environment • set via ENV variable.

Table 18: Performance Optimization

Strategy	Example	Description
Async operations	`async def fetch_data():` `return await http_client.get(url)`	• Use `async def` for I/O-bound operations • enables concurrent request handling.
Redis caching	`from fastapi_cache import FastAPICache` `from fastapi_cache.backends.redis import RedisBackend` `@cache(expire=60)`	• Caches responses in Redis • reduces database load for repeated queries.
Response caching headers	`@app.get("/", response_headers={"Cache-Control": "max-age=3600"})`	• Sets HTTP caching headers • clients/proxies cache responses.
Connection pooling	`engine = create_engine(url, pool_size=20)`	• Reuses database connections • critical for high-throughput APIs.
ORJSONResponse	`app = FastAPI(default_response_class=ORJSONResponse)`	• Uses faster JSON library • 2-3x performance improvement over standard json.
Uvicorn workers	`uvicorn main:app --workers 4`	• Runs multiple worker processes • utilizes multiple CPU cores.
Gunicorn + Uvicorn	`gunicorn main:app --workers 4 --worker-class uvicorn.workers.UvicornWorker`	• Process manager with Uvicorn workers • production-grade deployment.
Docker deployment	`FROM python:3.14` `RUN pip install fastapi[standard]` `CMD ["fastapi", "run", "main.py", "--port", "80"]`	• Official Docker image pattern for FastAPI production deployment • uses `fastapi run` included in `fastapi[standard]`.

Table 19: Advanced Patterns

Pattern	Example	Description
GraphQL integration	`from strawberry.fastapi import GraphQLRouter` `app.include_router(GraphQLRouter(schema), prefix="/graphql")`	• Adds GraphQL endpoint using Strawberry • enables flexible query language.
Rate limiting	`from slowapi import Limiter` `@limiter.limit("5/minute")` `def endpoint():`	• Throttles requests per IP/user • prevents API abuse.
API versioning (URL)	`app.mount("/v1", v1_app)` `app.mount("/v2", v2_app)`	• Versions API via URL path • most common versioning strategy.
API versioning (header)	`version = request.headers.get("API-Version", "v1")`	• Reads version from custom header • cleaner URLs but less discoverable.
Class-based views	`from fastapi_utils.cbv import cbv` `@cbv(router)` `class ItemAPI:` `@router.get("/items")`	• Groups related endpoints in class • reduces boilerplate for CRUD operations.
MessagePack serialization	`from msgpack_asgi import MessagePackMiddleware` `app.add_middleware(MessagePackMiddleware)`	• Uses binary format for smaller payloads • faster than JSON for large data.
Request ID tracking	`@app.middleware("http")` `async def add_request_id(request, call_next):`	• Adds unique ID to each request • enables distributed tracing.

Back to Backend Development

Next Topic: Fastify Node.js Framework Cheat Sheet

References

Video Resources

YouTube - Python FastAPI Tutorial (Part 1): Getting Started - https://www.youtube.com/watch?v=7AMjmCTumuo
YouTube - Python FastAPI Tutorial (Part 4): Pydantic Schemas - https://www.youtube.com/watch?v=9GHxnttXxrA
YouTube - Python FastAPI Tutorial (Part 5): Adding a Database - https://www.youtube.com/watch?v=NvOV3ig2tGY
YouTube - Python FastAPI Tutorial (Part 6): Completing CRUD - https://www.youtube.com/watch?v=VyoGAoxQhxM
YouTube - FastAPI Tutorial for Beginners – Full Course - https://www.youtube.com/watch?v=VirndPTeRaw
YouTube - How to work with Environment variables and Configuration Files in FastAPI - https://www.youtube.com/watch?v=TI1jU2YbIPA
YouTube - Streaming in React the Simple Way: Server-Sent Events (with FastAPI) - https://www.youtube.com/watch?v=hOAAg1WaZh8
YouTube - Swagger Docs - The Ultimate Guide to Professional API (Part 6) - https://www.youtube.com/watch?v=0JDQ6y297RE

GitHub Repositories

GitHub - seapagan/fastapi_async_sqlalchemy2_example - https://github.com/seapagan/fastapi_async_sqlalchemy2_example
GitHub - strawberry-graphql/strawberry - https://github.com/strawberry-graphql/strawberry/discussions/1863
GitHub - egoan82/fastapi-with-redis-as-cache - https://github.com/egoan82/fastapi-with-redis-as-cache
GitHub - darixsamani/fastapi-rate-limiter - https://github.com/darixsamani/fastapi-rate-limiter
GitHub - dmontagu/fastapi-utils - https://github.com/dmontagu/fastapi-utils/blob/master/fastapi_utils/cbv.py

FastAPI New Features

FastAPI CLI - https://fastapi.tiangolo.com/fastapi-cli/
FastAPI Separate OpenAPI Schemas - https://fastapi.tiangolo.com/how-to/separate-openapi-schemas/
FastAPI Docker Deployment - https://fastapi.tiangolo.com/deployment/docker/
FastAPI Generate Clients - https://fastapi.tiangolo.com/advanced/generate-clients/