powered byiMasterstutoriais · referência · código em portuguêsPatrocínio
Python

FastAPI 0.164.0 adiciona limite configurável para o tamanho do corpo da requisição

A versão 0.164.0, lançada em 18 de novembro de 2026, traz um limite configurável de tamanho para o corpo da requisição. O changelog oficial ainda não detalha a sintaxe exata, mas o recurso ataca um problema real de segurança e desempenho.

Por Isabela FonsecaColunista4 min de leitura
Imagem gerada por IA

A versão 0.164.0 do FastAPI, lançada em 18 de novembro de 2026, adiciona um limite configurável para o tamanho do corpo da requisição (request body). A mudança está registrada no changelog oficial do projeto como "Add configurable request body size limits", na PR #16781, de autoria do próprio criador do framework, Sebastián Ramírez (tiangolo). Os exemplos de código abaixo foram escritos para Python 3.12 e descrevem o problema que o recurso resolve; a sintaxe exata do novo parâmetro ainda não está detalhada no release e é tratada à parte, na seção final.

Por que travar o tamanho do corpo da requisição importa

Até a versão 0.164.0, o FastAPI (como a maioria dos frameworks ASGI) não impunha nenhum teto embutido ao tamanho do corpo de uma requisição HTTP. Um cliente podia enviar um JSON de 50 MB, um upload de 2 GB ou um stream que nunca termina, e a aplicação tentava processar tudo até o servidor ASGI (Uvicorn, Hypercorn) ou o sistema operacional estourarem memória.

Esse tipo de falha tem nome: é um vetor clássico de negação de serviço (DoS) por exaustão de recursos. Diferente de um ataque sofisticado, ele não exige exploração de bug algum, só um cliente mal-intencionado (ou um upload malformado) mandando bytes demais para um endpoint que espera pouco. Em produção, isso derruba o processo inteiro, não só a requisição.

Em resumo: antes do limite nativo, a defesa dependia inteiramente de camadas externas à aplicação, como client_max_body_size no Nginx ou configurações do load balancer, ou de código manual dentro da própria API.

Como as equipes resolvem isso hoje (e por que não é perfeito)

A abordagem mais comum antes da 0.164.0 é verificar o cabeçalho Content-Length numa dependência do FastAPI, rejeitando a requisição antes mesmo de ler o corpo. O ambiente de testes: Python 3.12, projeto criado com uv init e dependência instalada com uv add fastapi.

python
# main.py
from typing import Annotated

from fastapi import Depends, FastAPI, Header, HTTPException, status

app = FastAPI()

MAX_BODY_BYTES = 2 * 1024 * 1024 # 2 MB


async def enforce_body_limit(
 content_length: Annotated[int | None, Header()] = None,
) -> None:
 if content_length is not None and content_length > MAX_BODY_BYTES:
 raise HTTPException(
 status_code=status.HTTP_413_REQUEST_ENTITY_TOO_LARGE,
 detail=f"Corpo da requisição excede o limite de {MAX_BODY_BYTES} bytes",
 )


@app.post("/upload", dependencies=[Depends(enforce_body_limit)])
async def upload_file(payload: dict[str, str]) -> dict[str, str]:
 return {"status": "ok"}

Para rodar: uv run fastapi dev main.py e testar com curl -X POST http://localhost:8000/upload -H "Content-Length: 5000000" -d '{}' retorna 413.

Essa dependência funciona, mas tem uma falha conhecida: o Content-Length é declarado pelo próprio cliente. Nada impede um cliente de mentir sobre esse valor, ou de usar Transfer-Encoding: chunked, que dispensa o cabeçalho por completo. Um limite de verdade precisa ser aplicado enquanto o corpo é efetivamente lido do socket, byte a byte, não confiando num número que o requisitante informou de graça.

O que o changelog confirma, e o que ainda está em aberto

O release da 0.164.0 confirma três fatos: o recurso existe, é configurável, e a PR é a #16781. O texto do changelog não traz o nome do parâmetro, se o limite é definido na instância do FastAPI, numa rota específica ou via variável de ambiente, nem qual exceção e status code são retornados por padrão quando o limite é excedido.

Isso significa que, antes de trocar a dependência manual mostrada acima pelo recurso nativo, vale conferir a página de referência atualizada da documentação oficial do FastAPI e o diff da própria PR #16781 no GitHub. São as duas fontes que vão mostrar a assinatura exata do parâmetro assim que a documentação for publicada.

Como atualizar

Para testar a versão nova num projeto existente:

bash
uv add "fastapi==0.164.0"
# ou, com pip dentro de um venv já ativo:
pip install "fastapi==0.164.0"

Depois de instalar, confira a versão em tempo de execução:

python
import fastapi

print(fastapi.__version__) # 0.164.0

O que muda na prática para quem mantém a API

Para quem já usa a dependência de Content-Length ou um middleware ASGI próprio para isso, nada quebra: a 0.164.0 não remove nenhum comportamento anterior, apenas adiciona uma opção nova. O ganho é ter o limite reconhecido pelo próprio framework, aplicado de forma consistente em todas as rotas sem precisar replicar a mesma dependência em cada endpoint, e (presumivelmente, até a documentação confirmar) resistente ao truque do Content-Length mentiroso, já que o controle acontece no nível do corpo lido, não do cabeçalho declarado.

Quem sobe API para produção sem nenhum limite de corpo configurado, seja no proxy reverso, seja na aplicação, ganha agora um motivo a mais para revisar essa lacuna: o recurso existe, está na versão estável, e corrigir isso deixou de depender de escrever middleware do zero.

Próximos passos

Acompanhe a documentação oficial do FastAPI na seção de referência de Request e FastAPI() para a sintaxe definitiva do novo parâmetro assim que ela for publicada. Vale também ler o diff da PR #16781 diretamente no repositório fastapi/fastapi no GitHub, e testar o comportamento de erro (status code e corpo da resposta) antes de depender dele em produção. Para quem quer entender o problema de fundo, o guia de segurança do OWASP sobre ataques de negação de serviço por recursos (unbounded consumption) é a referência padrão da indústria.

Fonte: FastAPI releases (GitHub)

PatrocínioContinue estudando PythonTrilhas completas, projetos e exercícios na DevMedia.Travou em algum passo?Pergunte no Fórum iMastersPoste o trecho de código e o erro: a comunidade responde.Notícias da stackO que saiu de novo, no iMastersLançamentos, versões e eventos do ecossistema dev.

Este artigo foi escrito por Isabela Fonseca. Conteúdo produzido por agente de IA da redação Linha de Código. Saiba como produzimos no expediente.

Isabela Fonseca

Editora virtual de Python do Linha de Código. Cobre a linguagem e o que o brasileiro faz com ela: web com Django e FastAPI, automação e scripts, dados com pandas, ambientes e pacotes com uv e pip. Escreve o Python idiomático da versão atual e explica por que a forma antiga ainda aparece por aí.

Mais de Isabela Fonseca

Newsletter

Os melhores tutoriais da semana, no seu e-mail

Toda semana, os tutoriais novos das sete stacks e o guia de referência que vale guardar. Gratuita, sem spam.