Como criar uma API com Python e FastAPI: do zero à produção

FastAPI é o framework Python para criação de APIs REST que mais cresceu nos últimos anos — e por boas razões. Combina alta performance (comparável ao Node.js e Go graças ao asyncio), validação automática de dados com Pydantic, documentação interativa gerada automaticamente, e uma sintaxe moderna com type hints. Em 2026, FastAPI é a escolha padrão para novas APIs Python, sustitunido Flask e Django REST Framework em muitos projetos.

Instalação e primeira API

pip install fastapi uvicorn[standard] pydantic

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def raiz():
    return {"mensagem": "API FastAPI funcionando!"}

@app.get("/ola/{nome}")
def saudar(nome: str):
    return {"saudacao": f"Olá, {nome}!"}

Execute com: uvicorn main:app --reload

Acesse http://localhost:8000/docs para ver a documentação Swagger interativa — gerada automaticamente pelo FastAPI com base nos type hints e docstrings. Essa documentação é executável diretamente no browser, sem Postman ou cURL.

Modelos Pydantic: validação automática de dados

from pydantic import BaseModel, EmailStr, field_validator
from typing import Optional
from datetime import datetime

class ProdutoCreate(BaseModel):
    nome: str
    preco: float
    estoque: int = 0
    descricao: Optional[str] = None

    @field_validator('preco')
    @classmethod
    def preco_positivo(cls, v):
        if v <= 0:
            raise ValueError('Preço deve ser maior que zero')
        return v

class ProdutoResponse(BaseModel):
    id: int
    nome: str
    preco: float
    estoque: int
    criado_em: datetime

Quando um request chega com dados inválidos (preço negativo, campo obrigatório ausente, tipo errado), FastAPI retorna automaticamente um erro 422 com detalhes de qual campo falhou e por quê — sem código adicional.

CRUD completo com banco de dados (SQLAlchemy)

pip install sqlalchemy databases[aiosqlite]

from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from datetime import datetime

DATABASE_URL = "sqlite:///./loja.db"
engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(bind=engine)
Base = declarative_base()

class Produto(Base):
    __tablename__ = "produtos"
    id = Column(Integer, primary_key=True, index=True)
    nome = Column(String, nullable=False)
    preco = Column(Float, nullable=False)
    estoque = Column(Integer, default=0)
    criado_em = Column(DateTime, default=datetime.utcnow)

Base.metadata.create_all(bind=engine)
app = FastAPI()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/produtos", status_code=201)
def criar_produto(produto: ProdutoCreate, db: Session = Depends(get_db)):
    db_produto = Produto(**produto.dict())
    db.add(db_produto)
    db.commit()
    db.refresh(db_produto)
    return db_produto

@app.get("/produtos")
def listar_produtos(skip: int = 0, limit: int = 20, db: Session = Depends(get_db)):
    return db.query(Produto).offset(skip).limit(limit).all()

@app.get("/produtos/{produto_id}")
def buscar_produto(produto_id: int, db: Session = Depends(get_db)):
    produto = db.query(Produto).filter(Produto.id == produto_id).first()
    if not produto:
        raise HTTPException(status_code=404, detail="Produto não encontrado")
    return produto

@app.delete("/produtos/{produto_id}", status_code=204)
def deletar_produto(produto_id: int, db: Session = Depends(get_db)):
    produto = db.query(Produto).filter(Produto.id == produto_id).first()
    if not produto:
        raise HTTPException(status_code=404, detail="Produto não encontrado")
    db.delete(produto)
    db.commit()

Deploy em produção

Para o arquivo Dockerfile:

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

Plataformas de deploy recomendadas: Railway.app (pull do GitHub, deploy automático), Render.com (plano free permanente para web services), ou Fly.io (containers Docker, mais configurável). FastAPI com Uvicorn suporta dezenas de milhares de requisições por segundo em hardware modesto — para a maioria dos projetos, você não vai precisar de mais infraestrutura do que a de entrada dessas plataformas por um bom tempo.