O que é Structured Output? Por que GPT, Gemini e Claude forçam JSON

De cara: Structured Output não é o prompt «por favor, devolva JSON». É a API bloqueando tokens ilegais na decodificação com um JSON Schema, para que a resposta final possa ser parseada por um programa. GPT, Gemini e Claude tornaram isso um recurso de primeira classe não porque a frase fica bem num slide, mas porque agentes, extração e preenchimento de formulários precisam ligar o modelo a um pipeline. Prosa falha no JSON.parse. Falha ainda mais no schema de downstream.

Este artigo está datado de 8 de setembro de 2026. Os três já conseguem restringir o JSON final para o usuário ou o próximo serviço: OpenAI via response_format.json_schema (strict), Gemini via responseMimeType + responseJsonSchema, Claude via o GA output_config.format (o output_format antigo de beta ainda funciona na transição). Como preencher os campos, e como os subconjuntos diferem, já desmontamos em agosto. Este texto responde duas perguntas: o que é, e por que os três tiveram que lançar. Para o passo a passo, veja Do prompt ao Structured Output. Para OpenAI vs Gemini, veja a comparação das APIs de Structured Output.

O que é Structured Output

Structured Output significa: você entrega um JSON Schema, e a resposta final do modelo tem de ser JSON que bata com ele. A garantia acontece enquanto cada token é gerado, não depois de o modelo «tentar parecer JSON». Os nomes diferem: OpenAI diz Structured Outputs, Google diz Structured Output, a Anthropic escreve structured outputs / JSON outputs. O s a mais é branding. O trabalho é o mesmo.

Pense em compilador e verificador de tipos. Um prompt é um comentário — o modelo pode ouvir. Um schema é o sistema de tipos — um nome de campo errado, um required faltando, uma string onde deveria ser number nunca são emitidos. O que o seu programa recebe é um objeto, não prosa embrulhada numa cerca ```json.

Um Schema que os três leem costuma ser achatado: raiz object, properties / required explícitos, additionalProperties: false. No strict da OpenAI, «opcional» muitas vezes é anulável em vez de sair do required. Os subconjuntos não são idênticos; pegue a interseção primeiro.

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "task": { "type": "string", "enum": ["extract", "classify", "summarize"] },
    "ok": { "type": "boolean" },
    "fields": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "orderId": { "type": "string" },
        "total": { "type": "number" },
        "note": { "type": ["string", "null"] }
      },
      "required": ["orderId", "total", "note"]
    }
  },
  "required": ["task", "ok", "fields"]
}

Não é JSON Mode, nem Tool Calling

Três nomes viram um só. Eles não estão na mesma camada:

JSON Mode só garante chaves que fecham e um JSON.parse bem-sucedido. O modelo ainda pode inventar order_id quando você pediu orderId, ou emitir o valor como string. Em produção, «parseia» não é «dá para inserir».

Tool Calling / Function Calling restringe a mão que pega a ferramenta, não a última frase para o usuário. Consultas de estoque, escrita de arquivos, tools/call do MCP ficam no Schema de ferramenta. Extrair e-mail, classificar um ticket, emitir JSON para uma API de downstream ficam no Structured Output. Um agente completo muitas vezes liga os dois — argumentos nas tools, a resposta final num Schema de saída. Para o empilhamento veja O que é o MCP e o fluxo de dados JSON do Agent.

Por que os três passaram a oferecer

Em 2023 ainda dava para apostar num prompt. Em 2026 um agente embute o modelo num loop: a saída cai num banco, na próxima ferramenta, ou no modelo de outro fornecedor. Os três laboratórios não combinaram um ciclo de imprensa. Eles bateram na mesma pressão de produto e no mesmo contrato — JSON Schema.

1. O consumidor de downstream é um programa, não um leitor. Chat pode ser prosa. Um pipeline precisa de objetos. Uma vírgula faltando, um campo renomeado, e a fila de retentativas da madrugada enche. Os fornecedores preferem cortar caminhos ilegais no decoder a ver cada cliente escrever um reparador.
2. Agentes tornaram a forma estável um requisito. Num loop de vários passos, o JSON da rodada anterior é a entrada desta. Um desvio e tudo depois está errado. Tool Calling responde «como estender a mão». Structured Output responde «como devolver a conclusão». Os dois precisam de Schema — veja se JSON Schema está virando o Contract do Agent.
3. Os prompts provaram que não bastavam. «Só JSON, sem markdown» fica bem num bench, depois deixa cair campos, adiciona cercas e parafraseia enums quando o contexto é longo, as ferramentas reinserem, ou as línguas se misturam. A decodificação restrita transforma «às vezes» num 400 da API ou num erro de Schema retentável.
4. JSON Schema já era o menor denominador comum. OpenAPI, inputSchema do MCP, exports de Pydantic / Zod — tudo isso. Um IDL privado do lado do modelo forçaria o Host a traduzir duas vezes. Ligar a resposta final ao mesmo Schema é o que deixa a troca de fornecedor barata.
5. A corrida virou «isso entra em produção», não «isso conversa». Quando um fornecedor lançou restrição rígida, gateways, frameworks de agente e listas de compras escreveram isso como obrigatório. Os outros dois ou acompanham ou não entram no mesmo grafo. Em setembro de 2026, uma API flagship sem Structured Output é difícil de vender para quem insere linhas.

Por isso as datas se agrupam: a OpenAI tornou Structured Outputs GA em agosto de 2024; o Gemini dobrou MIME + Schema na config de geração; o Claude ainda estava num header beta no fim de 2025 e agora envia output_config.format como campo estável. Os nomes nunca bateram. A pressão, sim.

Como GPT, Gemini e Claude ligam isso

Alinhe o conceito. Não cole campos entre fornecedores. A tabela é o que você pode colocar num doc em 8 de setembro de 2026 — não um tutorial completo de SDK.

Os envelopes diferem. O corpo do Schema deve ser o mesmo arquivo. Trocar de modelo muda o envelope, não orderId e required. Um esboço Claude (campos da spec; troque pelo Schema de negócio):

{
  "model": "claude-sonnet-4-6",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "Extract orderId and total from the order text"}
  ],
  "output_config": {
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "orderId": { "type": "string" },
          "total": { "type": "number" }
        },
        "required": ["orderId", "total"]
      }
    }
  }
}

A OpenAI coloca o mesmo schema em response_format.json_schema e liga o strict. O Gemini coloca em responseJsonSchema e declara o MIME type JSON. O lado a lado em Python completo ainda está em OpenAI vs Gemini. Superfícies de produto (ChatGPT / claude.ai / o app web do Gemini) nem sempre expõem a mesma restrição rígida. Escreva o SLA contra a API que você de fato chama.

O que a decodificação restrita realmente bloqueia

Sem Structured Output o modelo amostra o vocabulário inteiro e espera que o prompt o faça parecer JSON. Com Structured Output o decoder mantém um prefixo legal a partir do Schema: o próximo token só pode ser algo ainda válido — um ", orderId, true ou }. Caminhos ilegais ganham probabilidade zero.

Ela bloqueia a forma: vírgula sobrando, cercas de markdown, campos required faltando, deriva de tipo, chaves extras quando additionalProperties é false. Não bloqueia invenção: total é number e o número pode ser inventado; um valor legal de enum ainda pode ser o errado. Produção ainda passa o mesmo Schema por um validador; se falhar, você retenta, degrada ou vai para um humano. A decodificação restrita corta incidentes de parse, não alucinações.

Uma janela maior não muda isso. 1M tokens só alarga o que é visível; não restringe a forma da saída. Se você enfia um dump, ainda precisa de Schema — veja Janelas de contexto de 1M tokens.

O que fazer agora

1. Escreva o Schema antes de escolher o modelo. Nomes de campo, listas required e enums são o contrato do produto. GPT / Gemini / Claude são backends intercambiáveis. Guarde o contrato no repositório, não no prompt.
2. Extração, classificação, preenchimento de formulários → Structured Output. Efeitos colaterais → Tool Calling. Não finja que Structured Output já bateu na API de estoque. Reuso entre processos é quando você adiciona MCP.
3. Pegue a interseção de Schema entre fornecedores: objects achatados, additionalProperties: false, $ref raso, sem anyOf na raiz. O strict da OpenAI transforma «opcional» em anulável. Não mantenha três tabelas de campos que divergem.
4. A API passando não é a última checagem. Salve o Schema e dois ou três fixtures bons / ruins como JSON; valide e faça Diff neste site. Nada é enviado. Essa é a segunda porta depois da decodificação restrita.
5. Devolva falhas como estrutura: se o parse ou o segundo validador falhar, devolva um objeto (qual campo, tipo esperado). Não despeje um stack cru no próximo turno.

FAQ

Conclusão

Structured Output é o soquete das APIs flagship de 2026: a resposta final é decodificada contra um JSON Schema, então os programas param de apostar em chaves num prompt. GPT, Gemini e Claude lançaram porque agentes e extração escreveram «forma estável» nos testes de aceite, e JSON Schema era o contrato que os três já falavam. Não é JSON Mode. Não substitui Tool Calling nem MCP.

Troque o modelo, troque só os campos do envelope. Guarde nomes de campo e required no repositório, e valide amostras no local contra o mesmo Schema antes de ir ao ar. Como configurar cada API, e como isso se separa da camada de ferramentas, este site já cobre. Este artigo só deixa «o quê» e «por quê» inequívocos.