Build a REST API in 10 Minutes with FastAPI

FastAPI is the fastest-growing Python web framework. It's fast, type-safe, auto-generates documentation, and makes building APIs genuinely enjoyable. Here's how to build a production-ready REST API in under 10 minutes.

1. Project Setup

Create a new directory and install FastAPI with uvicorn:

mkdir my-api && cd my-api
pip install fastapi uvicorn[standard] pydantic

Create main.py:

from fastapi import FastAPI

app = FastAPI(title="My API", version="1.0")

# Run with: uvicorn main:app --reload

2. Your First Endpoint

@app.get("/")
async def root():
    return {"message": "Hello, World!"}

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

Run it:

uvicorn main:app --reload

3. Full CRUD Operations

from pydantic import BaseModel
from typing import Optional

class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    in_stock: bool = True

# In-memory store (use a database in production)
items_db = {}

@app.post("/items/", status_code=201)
async def create_item(item: Item):
    item_id = len(items_db) + 1
    items_db[item_id] = item.dict()
    return {"id": item_id, **item.dict()}

@app.get("/items/")
async def list_items(skip: int = 0, limit: int = 10):
    return list(items_db.values())[skip:skip + limit]

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    if item_id not in items_db:
        raise HTTPException(404, "Item not found")
    items_db[item_id] = item.dict()
    return items_db[item_id]

@app.delete("/items/{item_id}")
async def delete_item(item_id: int):
    if item_id not in items_db:
        raise HTTPException(404, "Item not found")
    del items_db[item_id]
    return {"deleted": True}

4. Request Validation

FastAPI uses Pydantic for automatic request validation:

from pydantic import BaseModel, Field, validator

class CreateUser(BaseModel):
    email: str = Field(..., regex=r"^[\w.-]+@[\w.-]+\.\w+$")
    password: str = Field(..., min_length=8)
    age: int = Field(..., ge=13, le=120)
    
    @validator("password")
    def password_strength(cls, v):
        if not any(c.isupper() for c in v):
            raise ValueError("Must contain uppercase")
        return v

Invalid requests automatically return a clear 422 error with field-level details. No manual validation code needed.

5. Authentication

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

security = HTTPBearer()

async def verify_token(
    credentials: HTTPAuthorizationCredentials = Depends(security)
):
    token = credentials.credentials
    # In production: verify JWT, check database, etc.
    if token != "secret-token":
        raise HTTPException(401, "Invalid token")
    return {"user_id": "user123"}

@app.get("/protected")
async def protected_route(user=Depends(verify_token)):
    return {"message": f"Hello {user['user_id']}"}

6. Database Integration

For a quick setup, use SQLite with Python's built-in sqlite3:

import sqlite3

def get_db():
    conn = sqlite3.connect("app.db")
    conn.row_factory = sqlite3.Row
    return conn

@app.on_event("startup")
async def startup():
    conn = get_db()
    conn.execute("""
        CREATE TABLE IF NOT EXISTS items (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            price REAL NOT NULL
        )
    """)
    conn.commit()
    conn.close()

7. Deployment

Deploy with Docker in under a minute:

# Dockerfile
FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t my-api .
docker run -p 8000:8000 my-api

Or deploy to a VPS with systemd:

# /etc/systemd/system/myapi.service
[Unit]
Description=My FastAPI App
After=network.target

[Service]
User=www-data
WorkingDirectory=/opt/myapi
ExecStart=uvicorn main:app --host 0.0.0.0 --port 8000
Restart=always

[Install]
WantedBy=multi-user.target

8. Useful Tools for API Development

Once your API is running, these tools help you test and debug:

• JSON Formatter — Format and validate your API responses
• Webhook Tester — Test webhook integrations
• JWT Decoder — Debug authentication tokens
• JSON Schema Validator — Validate request/response schemas
• URL Encoder/Decoder — Encode query parameters
• UUID Generator — Generate unique IDs for records