fastapi · YuriiMotov · Mar 19, 2026 · Mar 18, 2026
diff --git a/docs/pt/docs/advanced/json-base64-bytes.md b/docs/pt/docs/advanced/json-base64-bytes.md
@@ -0,0 +1,63 @@
+# JSON com bytes em Base64 { #json-with-bytes-as-base64 }
+
+Se sua aplicação precisa receber e enviar dados JSON, mas você precisa incluir dados binários nele, você pode codificá-los em base64.
+
+## Base64 vs Arquivos { #base64-vs-files }
+
+Primeiro, considere se você pode usar [Arquivos na request](../tutorial/request-files.md) para fazer upload de dados binários e [Response personalizada - FileResponse](./custom-response.md#fileresponse--fileresponse-) para enviar dados binários, em vez de codificá-los em JSON.
+
+JSON só pode conter strings codificadas em UTF-8, portanto não pode conter bytes puros.
+
+Base64 pode codificar dados binários em strings, mas, para isso, precisa usar mais caracteres do que os dados binários originais; assim, normalmente é menos eficiente do que arquivos comuns.
+
+Use base64 apenas se realmente precisar incluir dados binários em JSON e não puder usar arquivos para isso.
+
+## Pydantic `bytes` { #pydantic-bytes }
+
+Você pode declarar um modelo Pydantic com campos `bytes` e então usar `val_json_bytes` na configuração do modelo para indicar que deve usar base64 para *validar* os dados JSON de entrada; como parte dessa validação, ele decodificará a string base64 em bytes.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:9,29:35] hl[9] *}
+
+Se você verificar a `/docs`, verá que o campo `data` espera bytes codificados em base64:
+
+<div class="screenshot">
+<img src="/img/tutorial/json-base64-bytes/image01.png">
+</div>
+
+Você poderia enviar uma request assim:
+
+```json
+{
+    "description": "Some data",
+    "data": "aGVsbG8="
+}
+```
+
+/// tip | Dica
+
+`aGVsbG8=` é a codificação base64 de `hello`.
+
+///
+
+Em seguida, o Pydantic decodificará a string base64 e fornecerá os bytes originais no campo `data` do modelo.
+
+Você receberá uma response assim:
+
+```json
+{
+  "description": "Some data",
+  "content": "hello"
+}
+```
+
+## Pydantic `bytes` para dados de saída { #pydantic-bytes-for-output-data }
+
+Você também pode usar campos `bytes` com `ser_json_bytes` na configuração do modelo para dados de saída, e o Pydantic irá *serializar* os bytes como base64 ao gerar a response JSON.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,12:16,29,38:41] hl[16] *}
+
+## Pydantic `bytes` para dados de entrada e saída { #pydantic-bytes-for-input-and-output-data }
+
+E, claro, você pode usar o mesmo modelo configurado para usar base64 para lidar tanto com a entrada (*validar*) com `val_json_bytes` quanto com a saída (*serializar*) com `ser_json_bytes` ao receber e enviar dados JSON.
+
+{* ../../docs_src/json_base64_bytes/tutorial001_py310.py ln[1:2,19:26,29,44:46] hl[23:26] *}
diff --git a/docs/pt/docs/advanced/stream-data.md b/docs/pt/docs/advanced/stream-data.md
@@ -0,0 +1,117 @@
+# Transmitir dados { #stream-data }
+
+Se você quer transmitir dados que podem ser estruturados como JSON, você deveria [Transmitir JSON Lines](../tutorial/stream-json-lines.md).
+
+Mas se você quer transmitir dados binários puros ou strings, veja como fazer.
+
+/// info | Informação
+
+Adicionado no FastAPI 0.134.0.
+
+///
+
+## Casos de uso { #use-cases }
+
+Você pode usar isto para transmitir strings puras, por exemplo diretamente da saída de um serviço de AI LLM.
+
+Você também pode usá-lo para transmitir arquivos binários grandes, enviando cada bloco de dados à medida que o lê, sem precisar carregar tudo na memória de uma vez.
+
+Você também pode transmitir vídeo ou áudio desta forma; pode até ser gerado enquanto você processa e envia.
+
+## Um `StreamingResponse` com `yield` { #a-streamingresponse-with-yield }
+
+Se você declarar `response_class=StreamingResponse` na sua função de operação de rota, você pode usar `yield` para enviar cada bloco de dados em sequência.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}
+
+O FastAPI entregará cada bloco de dados para `StreamingResponse` como está, não tentará convertê-lo para JSON nem nada semelhante.
+
+### Funções de operação de rota não assíncronas { #non-async-path-operation-functions }
+
+Você também pode usar funções `def` normais (sem `async`) e usar `yield` da mesma forma.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[26:29] hl[27] *}
+
+### Sem anotação { #no-annotation }
+
+Você não precisa declarar a anotação de tipo de retorno para transmitir dados binários.
+
+Como o FastAPI não tentará converter os dados para JSON com Pydantic nem serializá-los de nenhuma forma, neste caso a anotação de tipo serve apenas para seu editor e ferramentas; ela não será usada pelo FastAPI.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[32:35] hl[33] *}
+
+Isso também significa que, com `StreamingResponse`, você tem a liberdade e a responsabilidade de produzir e codificar os bytes exatamente como precisam ser enviados, independentemente das anotações de tipo. 🤓
+
+### Transmitir bytes { #stream-bytes }
+
+Um dos principais casos de uso é transmitir `bytes` em vez de strings; você pode fazer isso sem problemas.
+
+{* ../../docs_src/stream_data/tutorial001_py310.py ln[44:47] hl[47] *}
+
+## Um `PNGStreamingResponse` personalizado { #a-custom-pngstreamingresponse }
+
+Nos exemplos acima, os bytes eram transmitidos, mas a resposta não tinha um cabeçalho `Content-Type`, então o cliente não sabia que tipo de dado estava recebendo.
+
+Você pode criar uma subclasse personalizada de `StreamingResponse` que define o cabeçalho `Content-Type` para o tipo de dado que você está transmitindo.
+
+Por exemplo, você pode criar um `PNGStreamingResponse` que define o cabeçalho `Content-Type` como `image/png` usando o atributo `media_type`:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}
+
+Em seguida, você pode usar essa nova classe em `response_class=PNGStreamingResponse` na sua função de operação de rota:
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}
+
+### Simular um arquivo { #simulate-a-file }
+
+Neste exemplo, estamos simulando um arquivo com `io.BytesIO`, que é um objeto semelhante a arquivo que vive somente na memória, mas nos permite usar a mesma interface.
+
+Por exemplo, podemos iterar sobre ele para consumir seu conteúdo, como faríamos com um arquivo.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[1:27] hl[3,12:13,25] *}
+
+/// note | Detalhes Técnicos
+
+As outras duas variáveis, `image_base64` e `binary_image`, são uma imagem codificada em Base64 e depois convertida para bytes, para então passá-la para `io.BytesIO`.
+
+Apenas para que possa viver no mesmo arquivo deste exemplo e você possa copiar e executar como está. 🥚
+
+///
+
+Ao usar um bloco `with`, garantimos que o objeto semelhante a arquivo seja fechado após a função geradora (a função com `yield`) terminar. Ou seja, após terminar de enviar a resposta.
+
+Isso não seria tão importante neste exemplo específico porque é um arquivo falso em memória (com `io.BytesIO`), mas com um arquivo real, seria importante garantir que o arquivo fosse fechado ao final do trabalho.
+
+### Arquivos e async { #files-and-async }
+
+Na maioria dos casos, objetos semelhantes a arquivo não são compatíveis com async e await por padrão.
+
+Por exemplo, eles não têm `await file.read()`, nem `async for chunk in file`.
+
+E, em muitos casos, lê-los seria uma operação bloqueante (que poderia bloquear o loop de eventos), pois são lidos do disco ou da rede.
+
+/// info | Informação
+
+O exemplo acima é, na verdade, uma exceção, porque o objeto `io.BytesIO` já está em memória, então lê-lo não bloqueará nada.
+
+Mas, em muitos casos, ler um arquivo ou um objeto semelhante a arquivo bloquearia.
+
+///
+
+Para evitar bloquear o loop de eventos, você pode simplesmente declarar a função de operação de rota com `def` normal em vez de `async def`. Assim, o FastAPI a executará em um worker de threadpool, evitando bloquear o loop principal.
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}
+
+/// tip | Dica
+
+Se você precisar chamar código bloqueante de dentro de uma função assíncrona ou uma função assíncrona de dentro de uma função bloqueante, você poderia usar o [Asyncer](https://asyncer.tiangolo.com), uma biblioteca irmã do FastAPI.
+
+///
+
+### `yield from` { #yield-from }
+
+Quando você está iterando sobre algo, como um objeto semelhante a arquivo, e faz `yield` para cada item, você também pode usar `yield from` para produzir cada item diretamente e pular o loop `for`.
+
+Isso não é particular do FastAPI, é apenas Python, mas é um truque útil para conhecer. 😎
+
+{* ../../docs_src/stream_data/tutorial002_py310.py ln[37:40] hl[40] *}
diff --git a/docs/pt/docs/advanced/strict-content-type.md b/docs/pt/docs/advanced/strict-content-type.md
@@ -0,0 +1,88 @@
+# Verificação Estrita de Content-Type { #strict-content-type-checking }
+
+Por padrão, o **FastAPI** usa verificação estrita do cabeçalho `Content-Type` para corpos de requisição JSON; isso significa que requisições JSON devem incluir um `Content-Type` válido (por exemplo, `application/json`) para que o corpo seja interpretado como JSON.
+
+## Risco de CSRF { #csrf-risk }
+
+Esse comportamento padrão oferece proteção contra uma classe de ataques de **Cross-Site Request Forgery (CSRF)** em um cenário muito específico.
+
+Esses ataques exploram o fato de que navegadores permitem que scripts enviem requisições sem fazer qualquer verificação de preflight de CORS quando:
+
+- não têm um cabeçalho `Content-Type` (por exemplo, usando `fetch()` com um corpo `Blob`)
+- e não enviam nenhuma credencial de autenticação.
+
+Esse tipo de ataque é relevante principalmente quando:
+
+- a aplicação está em execução localmente (por exemplo, em `localhost`) ou em uma rede interna
+- e a aplicação não tem autenticação, pressupondo que qualquer requisição da mesma rede é confiável.
+
+## Exemplo de Ataque { #example-attack }
+
+Imagine que você desenvolve uma forma de executar um agente de IA local.
+
+Ele fornece uma API em
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Há também um frontend em
+
+```
+http://localhost:8000
+```
+
+/// tip | Dica
+
+Observe que ambos têm o mesmo host.
+
+///
+
+Usando o frontend, você pode fazer o agente de IA executar ações em seu nome.
+
+Como está em execução localmente e não na Internet aberta, você decide não configurar autenticação, confiando apenas no acesso à rede local.
+
+Então um de seus usuários poderia instalá-lo e executá-lo localmente.
+
+Em seguida, poderia abrir um site malicioso, por exemplo:
+
+```
+https://evilhackers.example.com
+```
+
+E esse site malicioso envia requisições usando `fetch()` com um corpo `Blob` para a API local em
+
+```
+http://localhost:8000/v1/agents/multivac
+```
+
+Mesmo que o host do site malicioso e o da aplicação local sejam diferentes, o navegador não acionará uma requisição preflight de CORS porque:
+
+- Está em execução sem autenticação, não precisa enviar credenciais.
+- O navegador acha que não está enviando JSON (devido à falta do cabeçalho `Content-Type`).
+
+Então o site malicioso poderia fazer o agente de IA local enviar mensagens raivosas ao ex-chefe do usuário... ou pior. 😅
+
+## Internet Aberta { #open-internet }
+
+Se sua aplicação está na Internet aberta, você não “confiaria na rede” nem deixaria qualquer pessoa enviar requisições privilegiadas sem autenticação.
+
+Atacantes poderiam simplesmente executar um script para enviar requisições à sua API, sem necessidade de interação do navegador, então você provavelmente já está protegendo quaisquer endpoints privilegiados.
+
+Nesse caso, esse ataque/risco não se aplica a você.
+
+Esse risco e ataque é relevante principalmente quando a aplicação roda na rede local e essa é a única proteção presumida.
+
+## Permitindo Requisições sem Content-Type { #allowing-requests-without-content-type }
+
+Se você precisa dar suporte a clientes que não enviam um cabeçalho `Content-Type`, você pode desativar a verificação estrita definindo `strict_content_type=False`:
+
+{* ../../docs_src/strict_content_type/tutorial001_py310.py hl[4] *}
+
+Com essa configuração, requisições sem um cabeçalho `Content-Type` terão o corpo interpretado como JSON, o mesmo comportamento das versões mais antigas do FastAPI.
+
+/// info | Informação
+
+Esse comportamento e configuração foram adicionados no FastAPI 0.132.0.
+
+///
diff --git a/docs/pt/docs/editor-support.md b/docs/pt/docs/editor-support.md
@@ -0,0 +1,23 @@
+# Suporte a Editores { #editor-support }
+
+A [FastAPI Extension](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) oficial melhora seu fluxo de trabalho de desenvolvimento com descoberta e navegação de *operação de rota*, além de implantação no FastAPI Cloud e transmissão ao vivo de logs.
+
+Para mais detalhes sobre a extensão, consulte o README no [repositório do GitHub](https://github.com/fastapi/fastapi-vscode).
+
+## Configuração e Instalação { #setup-and-installation }
+
+A **FastAPI Extension** está disponível para [VS Code](https://code.visualstudio.com/) e [Cursor](https://www.cursor.com/). Pode ser instalada diretamente pelo painel de Extensões de cada editor, pesquisando por "FastAPI" e selecionando a extensão publicada por **FastAPI Labs**. A extensão também funciona em editores no navegador, como [vscode.dev](https://vscode.dev) e [github.dev](https://github.dev).
+
+### Descoberta da Aplicação { #application-discovery }
+
+Por padrão, a extensão descobre automaticamente aplicações FastAPI no seu workspace procurando por arquivos que instanciam `FastAPI()`. Se a detecção automática não funcionar para a estrutura do seu projeto, você pode especificar um ponto de entrada via `[tool.fastapi]` em `pyproject.toml` ou pela configuração `fastapi.entryPoint` do VS Code usando notação de módulo (por exemplo, `myapp.main:app`).
+
+## Funcionalidades { #features }
+
+- **Explorador de Operações de Rota** - Uma visualização em árvore na barra lateral de todas as <dfn title="rotas, endpoints">*operações de rota*</dfn> da sua aplicação. Clique para ir diretamente a qualquer definição de rota ou de router.
+- **Pesquisa de Rotas** - Pesquise por path, método ou nome com <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd> (no macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd>).
+- **Navegação com CodeLens** - Links clicáveis acima das chamadas do cliente de testes (por exemplo, `client.get('/items')`) que levam à *operação de rota* correspondente, facilitando a navegação entre testes e implementação.
+- **Implantar no FastAPI Cloud** - Implantação com um clique da sua aplicação no [FastAPI Cloud](https://fastapicloud.com/).
+- **Transmitir logs da aplicação** - Transmissão em tempo real dos logs da aplicação implantada no FastAPI Cloud, com filtragem por nível e busca de texto.
+
+Se quiser se familiarizar com as funcionalidades da extensão, você pode abrir o walkthrough da extensão acessando a Paleta de Comandos (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> ou no macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd>), selecionando "Welcome: Open walkthrough..." e, em seguida, escolhendo o walkthrough "Get started with FastAPI".