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 aNodeJS eGo (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) eJSON Schema.

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

Patrocinadores¶

Patrocinador Keystone¶

Patrocinadores Ouro e Prata¶

Outros patrocinadores

Opiniões¶

"[...] Estou usandoFastAPI muito esses dias. [...] Estou na verdade planejando utilizar ele em todos os times deserviços ML na Microsoft. Alguns deles estão sendo integrados no _core do produtoWindows e alguns produtosOffice._"

"Nós adotamos a bibliotecaFastAPI para iniciar um servidorREST que pode ser consultado para obterprevisões. [para o Ludwig]"

"ANetflix tem o prazer de anunciar o lançamento open-source do nosso framework de orquestração degerenciamento de crises:Dispatch! [criado comFastAPI]"

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

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

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

"Nós trocamos nossasAPIs porFastAPI [...] Acredito que você gostará dele [...]"

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

Mini documentário do FastAPI¶

Há ummini 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çãoCLI para ser utilizada no terminal ao invés de uma API web, dê uma olhada noTyper.

Typer é o irmão menor do FastAPI. E seu propósito é ser oFastAPI 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 umambiente virtual e então instale o FastAPI:

$pipinstall"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 arquivomain.py com:

fromfastapiimportFastAPIapp=FastAPI()@app.get("/")defread_root():return{"Hello":"World"}@app.get("/items/{item_id}")defread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}

fromfastapiimportFastAPIapp=FastAPI()@app.get("/")asyncdefread_root():return{"Hello":"World"}@app.get("/items/{item_id}")asyncdefread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}

Rode¶

Rode o servidor com:

$fastapidevmain.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 WatchFilesINFO:     Started server process [2248757]INFO:     Waiting for application startup.INFO:     Application startup complete.

Verifique¶

Abra seu navegador emhttp://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 nospaths/ e/items/{item_id}.
• Ambospaths fazemoperaçõesGET (também conhecido comométodos HTTP).
• Opath/items/{item_id} tem umparâmetro de pathitem_id que deve ser umint.
• Opath/items/{item_id} tem umparâmetro queryqstr opcional.

Documentação Interativa da API¶

Agora vá parahttp://127.0.0.1:8000/docs.

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

Documentação Alternativa da API¶

E agora, vá parahttp://127.0.0.1:8000/redoc.

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

Evoluindo o Exemplo¶

Agora modifique o arquivomain.py para receber um corpo de uma requisiçãoPUT.

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

fromfastapiimportFastAPIfrompydanticimportBaseModelapp=FastAPI()classItem(BaseModel):name:strprice:floatis_offer:bool|None=None@app.get("/")defread_root():return{"Hello":"World"}@app.get("/items/{item_id}")defread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}@app.put("/items/{item_id}")defupdate_item(item_id:int,item:Item):return{"item_name":item.name,"item_id":item_id}

O servidorfastapi dev deverá recarregar automaticamente.

Evoluindo a Documentação Interativa da API¶

Agora vá parahttp://127.0.0.1:8000/docs.

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

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

• 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:

Evoluindo a Documentação Alternativa da API¶

E agora, vá parahttp://127.0.0.1:8000/redoc.

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

Recapitulando¶

Resumindo, você declarauma 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.

ApenasPython padrão.

Por exemplo, para umint:

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).
  • Objetosdatetime.
  • ObjetosUUID.
  • 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 umitem_id no path para requisiçõesGET ePUT.
• Validar queitem_id é do tipoint para requisiçõesGET ePUT.
  • Se não for, o cliente verá um erro útil e claro.
• Verificar se existe um parâmetro query opcional nomeado comoq (como emhttp://127.0.0.1:8000/items/foo?q=somequery) para requisiçõesGET.
  • Como o parâmetroq é declarado com= None, ele é opcional.
  • Sem oNone ele seria obrigatório (como o corpo no caso dePUT).
• Para requisiçõesPUT para/items/{item_id}, lerá o corpo como JSON:
  • Verifica que tem um atributo obrigatórioname que deve serstr.
  • Verifica que tem um atributo obrigatórioprice que tem que ser umfloat.
  • Verifica que tem um atributo opcionalis_offer, que deve ser umbool, 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:

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

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

• Declaração deparâmetros de diferentes lugares como:cabeçalhos,cookies,campos de formulários earquivos.
• Como configurarlimitações de validação comomaximum_length ouregex.
• Um poderoso e fácil de usar sistema deInjeção de Dependência.
• Segurança e autenticação, incluindo suporte paraOAuth2 com autenticação comJWT tokens eHTTP Basic.
• Técnicas mais avançadas (mas igualmente fáceis) para declaração demodelos JSON profundamente aninhados (graças ao Pydantic).
• IntegraçõesGraphQL com oStrawberry e outras bibliotecas.
• Muitos recursos extras (graças ao Starlette) como:
  • WebSockets
  • testes extremamente fáceis baseados em HTTPX epytest
  • CORS
  • Cookie Sessions
  • ...e mais.

Implemente sua aplicação (opcional)¶

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

Se você já tem uma conta naFastAPI 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:

$fastapiloginYou are logged in to FastAPI Cloud 🚀

Depois, implemente sua aplicação:

$fastapideployDeploying 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 doFastAPI.

Ela simplifica o processo deconstruir,implantar eacessar uma API com esforço mínimo.

Traz a mesmaexperiência do desenvolvedor de construir aplicações com FastAPI paraimplantá-las na nuvem. 🎉

A FastAPI Cloud é a principal patrocinadora e financiadora dos projetos open source do ecossistemaFastAPI 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çõesFastAPI rodando sob Uvicorn comoum 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çãoComparações.

Dependências¶

O FastAPI depende do Pydantic e do Starlette.

Dependênciasstandard¶

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

Utilizado pelo Pydantic:

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

Utilizado pelo Starlette:

• httpx - Obrigatório caso você queira utilizar oTestClient.
• 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, comrequest.form().

Utilizado pelo FastAPI:

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

Sem as dependênciasstandard¶

Se você não deseja incluir as dependências opcionaisstandard, você pode instalar utilizandopip install fastapi ao invés depip install "fastapi[standard]".

Sem ofastapi-cloud-cli¶

Se você quiser instalar o FastAPI com as dependências padrão, mas sem ofastapi-cloud-cli, você pode instalar compip 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 oORJSONResponse.
• ujson - Obrigatório se você deseja utilizar oUJSONResponse.

Licença¶

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