FastAPI Tutorial: Crie APIs Python Mais Rápidas e com Documentação Automática

Durante anos, se você queria construir uma API em Python, a escolha era binária: ou você usava o Django (pesado, bateria inclusa, monolítico) ou o Flask (leve, mas você tinha que montar tudo manualmente).

Ambos funcionam, mas ambos nasceram em uma era em que a web era majoritariamente síncrona e a tipagem de dados em Python era apenas uma sugestão opcional.

Então surgiu o FastAPI, criado por Sebastián Ramírez e hoje mantido como projeto open source em fastapi.tiangolo.com. Em pouco tempo virou uma das escolhas mais comuns entre devs Python, principalmente em times que constroem APIs para produtos de IA e machine learning.

Resumo rápido

• A própria documentação oficial do FastAPI afirma que o framework tem performance “on par with NodeJS and Go”, graças ao Starlette (camada web) e ao Pydantic (validação de dados).
• Segundo o State of Python 2025 (pesquisa JetBrains/PSF), o uso do FastAPI entre devs Python saltou de 29% para 38%, ultrapassando Django (35%) e Flask (34%).
• Você declara tipos Python normais na função e ganha de graça: validação automática, documentação interativa (Swagger UI) e suporte nativo a código assíncrono.

O Segredo: Type Hints e Pydantic

O FastAPI não trabalha sozinho. Ele se apoia em duas bibliotecas: o Starlette cuida da parte web (rotas, requisições assíncronas) e o Pydantic cuida da validação de dados.

A grande sacada do framework foi abraçar os type hints (dicas de tipo) do Python moderno. Em vez de escrever código manual para checar se o usuário enviou um número ou um texto, você apenas declara o tipo no parâmetro da função. O FastAPI lê essa declaração e usa o Pydantic para validar tudo antes mesmo do seu código rodar.

Tutorial: Sua Primeira API em FastAPI

Vamos ver isso na prática.

1. Instalação

Você vai precisar do FastAPI e de um servidor ASGI (o Uvicorn) para rodar a aplicação.

pip install fastapi "uvicorn[standard]"

2. O “Hello World” Moderno

Crie um arquivo main.py:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"mensagem": "Olá, Mundo! O FastAPI é incrível."}

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

Para rodar, vá no terminal:

uvicorn main:app --reload

Nota: o --reload faz o servidor reiniciar automaticamente a cada vez que você salva o arquivo (ótimo para desenvolvimento, nunca use em produção).

3. A Documentação Automática (Swagger UI)

Aqui está o ganho mais visível do framework.

Com o servidor rodando, abra o navegador e vá para:

http://127.0.0.1:8000/docs

Você verá uma interface interativa gerada pelo padrão OpenAPI. Essa é a Swagger UI, e o FastAPI a monta sozinho, lendo o seu código. Dá para clicar nos botões, testar as rotas e ver as respostas, sem escrever uma linha de HTML ou YAML.

4. Validação de Dados com Pydantic

Agora vamos criar algo mais próximo da vida real. Imagine receber dados de um produto. No Flask puro, você teria que checar campo por campo na mão. No FastAPI, você cria um modelo Pydantic:

from typing import Optional
from pydantic import BaseModel

# Criamos uma "forma" de como o dado deve ser
class Produto(BaseModel):
    nome: str
    preco: float
    em_oferta: bool = False  # Campo opcional com valor padrão
    descricao: Optional[str] = None

@app.post("/produtos/")
async def criar_produto(produto: Produto):
    # Se chegou aqui, o dado JÁ é válido.
    # O 'produto' já é um objeto, não um dicionário solto.
    preco_final = produto.preco
    if produto.em_oferta:
        preco_final = produto.preco * 0.9

    return {
        "nome": produto.nome,
        "preco_final": preco_final,
        "descricao": produto.descricao
    }

Tente enviar um JSON em que o preco é um texto (por exemplo, "preco": "caro"). O FastAPI retorna um erro detalhado automaticamente, dizendo exatamente qual campo está errado. Isso economiza horas de debugging manual.

5. Async: Concorrência Nativa

Você notou o async def no código acima?

O FastAPI é construído sobre o padrão ASGI (via Starlette), o que permite lidar com muitas requisições simultâneas sem travar o processo, de forma parecida com o modelo de concorrência do Node.js ou do Go.

Se você precisa consultar um banco de dados ou uma API externa, use await e o servidor continua livre para atender outras requisições enquanto espera a resposta. Vale reforçar: isso só traz ganho real quando as bibliotecas que você chama dentro da rota também são assíncronas (drivers de banco async, clientes HTTP async etc.). Chamar código síncrono e bloqueante dentro de um async def anula a vantagem.

Flask vs. FastAPI: Comparação Direta

Recurso	Flask	FastAPI
Filosofia	Minimalista, você escolhe as libs	Minimalista, mas com validação embutida
Padrão de servidor	WSGI (síncrono)	ASGI (assíncrono, com suporte a rotas síncronas também)
Validação	Manual ou via extensões (ex: Marshmallow)	Nativa e automática (Pydantic)
Documentação	Manual ou plugins	Automática, em /docs

Use Flask se você está mantendo um sistema legado ou fazendo um micro-app extremamente simples, onde tipagem não faz diferença prática.

Use FastAPI quando a API vai crescer, quando você quer validação de dados sem escrever isso à mão, ou quando o time precisa de documentação sempre atualizada sem esforço extra.

Conclusão

O FastAPI não é apenas mais um “framework novo”. Ele resolve duas dores reais do desenvolvimento de APIs em Python: validação de dados e documentação, deixando você focar na regra de negócio.

Se você já testou o net/http puro do Go ou o Gin e quer comparar como o ecossistema Python resolve o mesmo problema, o FastAPI é o ponto de partida mais indicado hoje. E se ainda não está familiarizado com o conceito básico por trás de tudo isso, vale revisar o que é uma API antes de avançar.

Desafio: pegue o código acima, adicione um campo novo ao modelo Produto (como estoque: int) e veja ele aparecer automaticamente na documentação em /docs, sem você fazer nada extra.

Depois de dominar o básico, o próximo passo natural é conectar a API a um banco de dados de verdade. Veja como fazer isso na prática em API Real: Go e PostgreSQL (CRUD Prático), que mostra o mesmo tipo de CRUD que você constrói com FastAPI, só que do lado do Go.

Perguntas frequentes

O FastAPI é mais rápido que o Flask?

Em termos de capacidade de lidar com requisições concorrentes, sim. O Flask roda sobre o padrão WSGI, que é síncrono por natureza, enquanto o FastAPI roda sobre ASGI (via Starlette), com suporte nativo a async/await. A própria documentação oficial do FastAPI afirma que a performance fica em patamar comparável ao Node.js e ao Go em benchmarks como o TechEmpower. Isso não significa que todo endpoint FastAPI será mais rápido automaticamente: se o código dentro da rota for bloqueante (uma query síncrona, por exemplo), a vantagem do async some.

O que é o Pydantic no FastAPI?

É a biblioteca de validação de dados usada nativamente pelo FastAPI, mantida em pydantic.dev. Ela usa os type hints do Python para garantir que os dados recebidos pela API (JSON) estejam no formato correto, como garantir que um preço seja um número e não um texto.

Preciso saber programação assíncrona (async/await) para usar FastAPI?

Não obrigatoriamente. O FastAPI funciona perfeitamente com funções normais (def). Mas para tirar proveito da concorrência e lidar com muitas requisições simultâneas sem travar, aprender async/await e usar bibliotecas compatíveis com asyncio é recomendado.

Grandes empresas usam FastAPI em produção?

Sim. A própria página oficial do FastAPI lista depoimentos de engenheiros da Microsoft (usado em serviços de ML integrados ao Windows e ao Office), da Uber (usado no Ludwig, ferramenta de machine learning) e da Netflix (usado no Dispatch, framework de gestão de crises open source da empresa), entre outros.