FastAPI Tutorial – Modern Python REST API Framework

Installation and First App

Install FastAPI and uvicorn (ASGI server) and run your first API in minutes.

# pip install fastapi uvicorn

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
    return {"message": "Hello from FastAPI!"}

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

# Run:
# uvicorn main:app --reload
# Visit: http://127.0.0.1:8000/docs  ← Auto Swagger UI!

Pydantic Models – Request/Response Validation

Use Pydantic models to define and validate request bodies automatically.

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr
from typing import Optional

app = FastAPI()

class User(BaseModel):
    name: str
    email: str
    age: int
    bio: Optional[str] = None

@app.post("/users/", response_model=User)
def create_user(user: User):
    # user is already validated and typed
    return user

# FastAPI auto-validates: wrong type = 422 error
# POST /users/ with {"name":"Alice","email":"a@b.com","age":30}

Dependency Injection

FastAPI's dependency injection system handles auth, DB connections, and shared logic.

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import HTTPBearer

app = FastAPI()
security = HTTPBearer()

def get_current_user(token = Depends(security)):
    if token.credentials != "secret-token":
        raise HTTPException(status_code=401, detail="Invalid")
    return {"user": "alice"}

@app.get("/protected")
def protected_route(user = Depends(get_current_user)):
    return {"message": f"Welcome {user['user']}"}

Async Support

FastAPI supports both sync and async endpoints natively.

import asyncio
from fastapi import FastAPI
import httpx

app = FastAPI()

@app.get("/async-data")
async def get_data():
    async with httpx.AsyncClient() as client:
        response = await client.get("https://api.github.com")
    return response.json()

FastAPI: Modern APIs With Automatic Validation and Docs

FastAPI is a modern framework built for APIs. Its standout trick: it uses Python type hints to automatically validate requests, serialize responses, and generate interactive API documentation — features you'd hand-code elsewhere.

from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()

class Item(BaseModel):          # the type hints ARE the validation
    name: str
    price: float

@app.post("/items")
async def create(item: Item):   # FastAPI validates the JSON against Item
    return {"total": item.price * 1.1}

Why it took off: declare a pydantic model with typed fields, and FastAPI enforces it — send malformed data and the client gets a clear 422 error, no manual checking. Those same models generate live, browsable API docs automatically, so your documentation can never drift from the code. Async-native: built on ASGI, it handles async def endpoints for high-concurrency I/O (many simultaneous requests) out of the box. Choose FastAPI for new JSON APIs and microservices where validation, docs, and performance matter; it pairs the speed of Node-style async with Python's ecosystem.

Interview Questions on FastAPI

• What is FastAPI and what is it known for?
• How does FastAPI use Python type hints?
• What is Pydantic and how does FastAPI use it?
• What is dependency injection in FastAPI?
• How does FastAPI generate interactive API documentation automatically?
• When should a route be async in FastAPI?
• How does FastAPI compare to Flask and Django REST Framework?

Related Topics