FastAPI¶

Framework FastAPI, alta performance, fácil de aprender, fácil de codar, pronto para produção

Documentação: https://fastapi.tiangolo.com

Código fonte: https://github.com/fastapi/fastapi

FastAPI é um moderno e rápido (alta performance) framework web para construção de APIs com Python, baseado nos type hints padrões do Python.

Os recursos chave são:

Rápido: alta performance, equivalente a NodeJS e Go (graças ao Starlette e Pydantic). Um dos frameworks mais rápidos disponíveis.
Rápido para codar: Aumenta a velocidade para desenvolver recursos entre 200% a 300%. *
Poucos bugs: Reduz cerca de 40% de erros induzidos por humanos (desenvolvedores). *
Intuitivo: Grande suporte a editores. Completação em todos os lugares. Menos tempo debugando.
Fácil: Projetado para ser fácil de aprender e usar. Menos tempo lendo docs.
Enxuto: Minimize duplicação de código. Múltiplas funcionalidades para cada declaração de parâmetro. Menos bugs.
Robusto: Tenha código pronto para produção. E com documentação interativa automática.
Baseado em padrões: Baseado em (e totalmente compatível com) os padrões abertos para APIs: OpenAPI (anteriormente conhecido como Swagger) e JSON Schema.

* estimativas baseadas em testes realizados com equipe interna de desenvolvimento, construindo aplicações em produção.

Patrocinadores¶

Patrocinadores Ouro e Prata¶

Outros patrocinadores

Opiniões¶

"[...] Estou usando FastAPI muito esses dias. [...] Estou na verdade planejando utilizar ele em todos os times de serviços ML na Microsoft. Alguns deles estão sendo integrados no _core do produto Windows e alguns produtos Office._"

Kabir Khan - Microsoft (ref)

"Nós adotamos a biblioteca FastAPI para iniciar um servidor REST que pode ser consultado para obter previsões. [para o Ludwig]"

Piero Molino, Yaroslav Dudin, e Sai Sumanth Miryala - Uber (ref)

"A Netflix tem o prazer de anunciar o lançamento open-source do nosso framework de orquestração de gerenciamento de crises: Dispatch! [criado com FastAPI]"

Kevin Glisson, Marc Vilanova, Forest Monsen - Netflix (ref)

"Estou muito entusiasmado com o FastAPI. É tão divertido!"

Brian Okken - Python Bytes apresentador do podcast (ref)

"Honestamente, o que você construiu parece super sólido e refinado. De muitas formas, é o que eu queria que o Hug fosse - é realmente inspirador ver alguém construir isso."

Timothy Crosley - criador doHug (ref)

"Se você está procurando aprender um framework moderno para construir APIs REST, dê uma olhada no FastAPI [...] É rápido, fácil de usar e fácil de aprender [...]"

"Nós trocamos nossas APIs por FastAPI [...] Acredito que você gostará dele [...]"

Ines Montani - Matthew Honnibal - fundadores da Explosion AI - criadores da spaCy (ref) - (ref)

"Se alguém estiver procurando construir uma API Python para produção, eu recomendaria fortemente o FastAPI. Ele é lindamente projetado, simples de usar e altamente escalável, e se tornou um componente chave para a nossa estratégia de desenvolvimento API first, impulsionando diversas automações e serviços, como o nosso Virtual TAC Engineer."

Deon Pillsbury - Cisco (ref)

Mini documentário do FastAPI¶

Há um mini documentário do FastAPI lançado no fim de 2025, você pode assisti-lo online:

Typer, o FastAPI das interfaces de linhas de comando¶

Se você estiver construindo uma aplicação CLI para ser utilizada no terminal ao invés de uma API web, dê uma olhada no Typer.

Typer é o irmão menor do FastAPI. E seu propósito é ser o FastAPI das CLIs. ⌨️ 🚀

Requisitos¶

FastAPI está nos ombros de gigantes:

Starlette para as partes web.
Pydantic para a parte de dados.

Instalação¶

Crie e ative um ambiente virtual e então instale o FastAPI:

$ pip install "fastapi[standard]"

---> 100%

Nota: Certifique-se de que você colocou "fastapi[standard]" com aspas, para garantir que funcione em todos os terminais.

Exemplo¶

Crie¶

Crie um arquivo main.py com:

from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

Ou use async def...

Se seu código utiliza async / await, use async def:

from typing import Union

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
async def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

Nota:

Se você não sabe, verifique a seção "Com pressa?" sobre async e await nas docs.

Rode¶

Rode o servidor com:

$ fastapi dev main.py

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │
 │  Running in development mode, for production use:   │
 │                                                     │
 │  fastapi run                                        │
 │                                                     │
 ╰─────────────────────────────────────────────────────╯

INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2248755] using WatchFiles
INFO:     Started server process [2248757]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Sobre o comando fastapi dev main.py...

O comando fastapi dev lê o seu arquivo main.py, identifica o aplicativo FastAPI nele, e inicia um servidor usando o Uvicorn.

Por padrão, o fastapi dev iniciará com auto-reload habilitado para desenvolvimento local.

Você pode ler mais sobre isso na documentação do FastAPI CLI.

Verifique¶

Abra seu navegador em http://127.0.0.1:8000/items/5?q=somequery.

Você verá a resposta JSON como:

{"item_id": 5, "q": "somequery"}

Você acabou de criar uma API que:

Recebe requisições HTTP nos paths / e /items/{item_id}.
Ambos paths fazem operações GET (também conhecido como métodos HTTP).
O path /items/{item_id} tem um parâmetro de path item_id que deve ser um int.
O path /items/{item_id} tem um parâmetro query q str opcional.

Documentação Interativa da API¶

Agora vá para http://127.0.0.1:8000/docs.

Você verá a documentação automática interativa da API (fornecida por Swagger UI):

Swagger UI

Documentação Alternativa da API¶

E agora, vá para http://127.0.0.1:8000/redoc.

Você verá a documentação automática alternativa (fornecida por ReDoc):

ReDoc

Evoluindo o Exemplo¶

Agora modifique o arquivo main.py para receber um corpo de uma requisição PUT.

Declare o corpo utilizando tipos padrão Python, graças ao Pydantic.

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Union[bool, None] = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

O servidor fastapi dev deverá recarregar automaticamente.

Evoluindo a Documentação Interativa da API¶

Agora vá para http://127.0.0.1:8000/docs.

A documentação interativa da API será automaticamente atualizada, incluindo o novo corpo:

Swagger UI

Clique no botão "Try it out", ele permitirá que você preencha os parâmetros e interaja diretamente com a API:

Swagger UI interaction

Então clique no botão "Execute", a interface do usuário irá se comunicar com a API, enviar os parâmetros, pegar os resultados e mostrá-los na tela:

Swagger UI interaction

Evoluindo a Documentação Alternativa da API¶

E agora, vá para http://127.0.0.1:8000/redoc.

A documentação alternativa também irá refletir o novo parâmetro query e o corpo:

ReDoc

Recapitulando¶

Resumindo, você declara uma vez os tipos dos parâmetros, corpo etc. como parâmetros de função.

Você faz isso com os tipos padrão do Python moderno.

Você não terá que aprender uma nova sintaxe, métodos ou classes de uma biblioteca específica etc.

Apenas Python padrão.

Por exemplo, para um int:

item_id: int

ou para um modelo mais complexo, Item:

item: Item

...e com essa única declaração você tem:

Suporte ao Editor, incluindo:
- Completação.
- Verificação de tipos.
Validação de dados:
- Erros automáticos e claros quando o dado é inválido.
- Validação até para objetos JSON profundamente aninhados.
Conversão de dados de entrada: vindo da rede para dados e tipos Python. Consegue ler:
- JSON.
- Parâmetros de path.
- Parâmetros query.
- Cookies.
- Cabeçalhos.
- Formulários.
- Arquivos.
Conversão de dados de saída: convertendo de tipos e dados Python para dados de rede (como JSON):
- Converte tipos Python (str, int, float, bool, list etc).
- Objetos datetime.
- Objetos UUID.
- Modelos de Banco de Dados.
- ...e muito mais.
Documentação interativa automática da API, incluindo 2 alternativas de interface de usuário:
- Swagger UI.
- ReDoc.

Voltando ao código do exemplo anterior, FastAPI irá:

Validar que existe um item_id no path para requisições GET e PUT.
Validar que item_id é do tipo int para requisições GET e PUT.
- Se não for, o cliente verá um erro útil e claro.
Verificar se existe um parâmetro query opcional nomeado como q (como em http://127.0.0.1:8000/items/foo?q=somequery) para requisições GET.
- Como o parâmetro q é declarado com = None, ele é opcional.
- Sem o None ele seria obrigatório (como o corpo no caso de PUT).
Para requisições PUT para /items/{item_id}, lerá o corpo como JSON:
- Verifica que tem um atributo obrigatório name que deve ser str.
- Verifica que tem um atributo obrigatório price que tem que ser um float.
- Verifica que tem um atributo opcional is_offer, que deve ser um bool, se presente.
- Tudo isso também funcionaria para objetos JSON profundamente aninhados.
Converter de e para JSON automaticamente.
Documentar tudo com OpenAPI, que poderá ser usado por:
- Sistemas de documentação interativos.
- Sistemas de clientes de geração de código automáticos, para muitas linguagens.
Fornecer diretamente 2 interfaces web de documentação interativa.

Nós apenas arranhamos a superfície, mas você já tem ideia de como tudo funciona.

Experimente mudar a seguinte linha:

    return {"item_name": item.name, "item_id": item_id}

...de:

        ... "item_name": item.name ...

...para:

        ... "item_price": item.price ...

...e veja como seu editor irá auto-completar os atributos e saberá os tipos:

editor support

Para um exemplo mais completo incluindo mais recursos, veja Tutorial - Guia do Usuário.

Alerta de Spoiler: o tutorial - guia do usuário inclui:

Declaração de parâmetros de diferentes lugares como: cabeçalhos, cookies, campos de formulários e arquivos.
Como configurar limitações de validação como maximum_length ou regex.
Um poderoso e fácil de usar sistema de Injeção de Dependência.
Segurança e autenticação, incluindo suporte para OAuth2 com autenticação com JWT tokens e HTTP Basic.
Técnicas mais avançadas (mas igualmente fáceis) para declaração de modelos JSON profundamente aninhados (graças ao Pydantic).
Integrações GraphQL com o Strawberry e outras bibliotecas.
Muitos recursos extras (graças ao Starlette) como:
- WebSockets
- testes extremamente fáceis baseados em HTTPX e pytest
- CORS
- Cookie Sessions
- ...e mais.

Implemente sua aplicação (opcional)¶

Você pode opcionalmente implantar sua aplicação FastAPI na FastAPI Cloud, vá e entre na lista de espera se ainda não o fez. 🚀

Se você já tem uma conta na FastAPI Cloud (nós convidamos você da lista de espera 😉), pode implantar sua aplicação com um único comando.

Antes de implantar, certifique-se de que está autenticado:

$ fastapi login

You are logged in to FastAPI Cloud 🚀

Depois, implemente sua aplicação:

$ fastapi deploy

Deploying to FastAPI Cloud...

✅ Deployment successful!

🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev

É isso! Agora você pode acessar sua aplicação nesse URL. ✨

Sobre a FastAPI Cloud¶

FastAPI Cloud é construída pelo mesmo autor e equipe por trás do FastAPI.

Ela simplifica o processo de construir, implantar e acessar uma API com esforço mínimo.

Traz a mesma experiência do desenvolvedor de construir aplicações com FastAPI para implantá-las na nuvem. 🎉

A FastAPI Cloud é a principal patrocinadora e financiadora dos projetos open source do ecossistema FastAPI and friends. ✨

Implante em outros provedores de nuvem¶

FastAPI é open source e baseado em padrões. Você pode implantar aplicações FastAPI em qualquer provedor de nuvem que escolher.

Siga os tutoriais do seu provedor de nuvem para implantar aplicações FastAPI com eles. 🤓

Performance¶

Testes de performance da Independent TechEmpower mostram aplicações FastAPI rodando sob Uvicorn como um dos frameworks Python mais rápidos disponíveis, somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)

Para entender mais sobre isso, veja a seção Comparações.

Dependências¶

O FastAPI depende do Pydantic e do Starlette.

Dependências `standard`¶

Quando você instala o FastAPI com pip install "fastapi[standard]", ele vem com o grupo standard de dependências opcionais:

Utilizado pelo Pydantic:

email-validator - para validação de email.

Utilizado pelo Starlette:

httpx - Obrigatório caso você queira utilizar o TestClient.
jinja2 - Obrigatório se você quer utilizar a configuração padrão de templates.
python-multipart - Obrigatório se você deseja suporte a "parsing" de formulário, com request.form().

Utilizado pelo FastAPI:

uvicorn - para o servidor que carrega e serve a sua aplicação. Isto inclui uvicorn[standard], que inclui algumas dependências (e.g. uvloop) necessárias para servir em alta performance.
fastapi-cli[standard] - que disponibiliza o comando fastapi.
- Isso inclui fastapi-cloud-cli, que permite implantar sua aplicação FastAPI na FastAPI Cloud.

Sem as dependências `standard`¶

Se você não deseja incluir as dependências opcionais standard, você pode instalar utilizando pip install fastapi ao invés de pip install "fastapi[standard]".

Sem o `fastapi-cloud-cli`¶

Se você quiser instalar o FastAPI com as dependências padrão, mas sem o fastapi-cloud-cli, você pode instalar com pip install "fastapi[standard-no-fastapi-cloud-cli]".

Dependências opcionais adicionais¶

Existem algumas dependências adicionais que você pode querer instalar.

Dependências opcionais adicionais do Pydantic:

pydantic-settings - para gerenciamento de configurações.
pydantic-extra-types - para tipos extras a serem utilizados com o Pydantic.

Dependências opcionais adicionais do FastAPI:

orjson - Obrigatório se você deseja utilizar o ORJSONResponse.
ujson - Obrigatório se você deseja utilizar o UJSONResponse.

Licença¶

Esse projeto é licenciado sob os termos da licença MIT.