FastAPI Tutorial: Build High-Performance APIs from Scratch (2026)
The first time I deployed a FastAPI service I was skeptical — another ASGI framework claiming speed and simplicity. After one project I was converted. The automatic OpenAPI docs, Pydantic validation, and native async support aren't marketing; they genuinely eliminate boilerplate that I used to write by hand. FastAPI performs on par with Node.js and Go for I/O-bound workloads because of Starlette underneath and the ASGI model.
We'll build a library API that tracks books and authors, with full CRUD, query filtering, and dependency injection for authentication. This covers the core patterns you'll use in every FastAPI project: path operations, request bodies, query parameters, and database sessions.
First Endpoint and the ASGI Server
FastAPI runs on an ASGI server like Uvicorn. The app is an ASGI application, and each route handler is an async function or a regular def — FastAPI handles the thread pool for sync functions. The automatic OpenAPI schema is generated from type hints, so defining your response model doubles as documentation.
from fastapi import FastAPI
app = FastAPI(title="Library API")
@app.get("/")
async def root():
return {"message": "Library API"}
# Run: uvicorn main:app --reloadPath Operations and Type Validation with Pydantic
FastAPI uses Pydantic models for request bodies and response schemas. Define a class inheriting BaseModel with type-annotated fields — validation, serialization, and OpenAPI generation happen automatically. Path and query parameters are validated from type hints too. If a client sends an invalid type, FastAPI returns a 422 with a descriptive error.
from pydantic import BaseModel
from typing import Optional
class Book(BaseModel):
title: str
author: str
year: int
isbn: Optional[str] = None
@app.post("/books", status_code=201)
async def create_book(book: Book):
return {"id": 1, **book.model_dump()}
@app.get("/books/{book_id}")
async def get_book(book_id: int):
return {"id": book_id, "title": "Sample", "author": "Unknown"}Query Parameters and Filtering
Query parameters that aren't part of the path are automatically taken from the URL's query string. You can make them optional, set defaults, and add validation like ge and le for numeric ranges. FastAPI also supports complex filtering with multiple optional parameters — the handler just checks each one.
from typing import Optional
@app.get("/books")
async def list_books(
author: Optional[str] = None,
min_year: Optional[int] = None,
limit: int = 10,
offset: int = 0
):
query = []
if author:
query.append(f"author={author}")
if min_year:
query.append(f"year>={min_year}")
return {"filters": query, "limit": limit, "offset": offset}Dependency Injection for Reusable Logic
FastAPI's dependency injection system is elegant: define a function that returns a value and use Depends() in path operations. Dependencies can themselves depend on other dependencies. I use this for authentication (verify bearer tokens), database sessions (get a DB connection), and pagination. The system resolves the graph at request time and caches results within a request scope.
from fastapi import Depends, HTTPException, Header
def verify_token(authorization: str = Header(...)):
if not authorization.startswith("Bearer "):
raise HTTPException(status_code=401)
return authorization[7:]
@app.get("/protected")
async def protected_route(user: str = Depends(verify_token)):
return {"user": user}Database Integration with SQLAlchemy Async
FastAPI pairs naturally with async database drivers like asyncpg (PostgreSQL) and aiosqlite. SQLAlchemy's async support uses create_async_engine and AsyncSession. Each request gets a session from a dependency, and we commit or rollback after the handler finishes. This non-blocking approach keeps the event loop responsive under concurrent load.
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker
DATABASE_URL = "sqlite+aiosqlite:///./library.db"
engine = create_async_engine(DATABASE_URL)
AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession)
async def get_db():
async with AsyncSessionLocal() as session:
yield sessionBackground Tasks and CORS Configuration
BackgroundTasks lets you schedule work after the response is sent — ideal for sending emails or processing uploads. CORS middleware is a one-liner that opens the API to frontend apps. FastAPI's middleware system lets you hook into request processing, and the built-in CORSMiddleware handles preflight OPTIONS requests automatically.
from fastapi import BackgroundTasks
from fastapi.middleware.cors import CORSMiddleware
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_methods=["*"],
allow_headers=["*"],
)
def log_new_book(title: str):
with open("audit.log", "a") as f:
f.write(f"New book: {title}\n")
@app.post("/books")
async def create_book(book: Book, tasks: BackgroundTasks):
tasks.add_task(log_new_book, book.title)
return {"status": "created"}Frequently Asked Questions
Do I need to write async handlers for every endpoint?
No. If a handler is synchronous (most ORM calls, file reads), use a regular def. FastAPI runs sync functions in a thread pool. Use async only when you're awaiting I/O operations like async HTTP calls or async DB drivers.
How does FastAPI compare to Flask for performance?
FastAPI / Starlette benchmarks 2-3x faster than Flask on throughput under concurrency. For most real-world APIs the difference is noticeable under load but not at low traffic. The bigger win is the auto-docs and validation.
Can I use FastAPI with Django ORM?
Yes, but I wouldn't. FastAPI works best with SQLAlchemy or databases that support async. If you need Django ORM, integrate it manually — but you lose the async benefit. Consider Django REST Framework if you're committed to Django.
How do I deploy FastAPI in production?
Use Uvicorn with Gunicorn as a process manager (uvicorn.workers.UvicornWorker), or use Uvicorn directly with systemd. Dockerize the app and run behind nginx or a cloud load balancer. Set workers to 2-4 per CPU core.
Originally published on Ayodhyyya. Last updated June 1, 2026.