---
title: "JSON inválido de um LLM: causas, reparo e retry | BroadRouter"
description: "Por que LLMs retornam JSON quebrado (code fences, texto extra, corte em max_tokens, vírgulas finais) e uma função Python testada que só repara o que é seguro."
url: https://broadrouter.com/pt/blog/fix-invalid-json-from-llm/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/fix-invalid-json-from-llm/) (atualizado em 2026-11-16).

# Como corrigir JSON inválido de um LLM: causas, reparo e retry

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15 · Atualizado em 2026-11-16

Confira primeiro o finish\_reason: uma resposta cortada em max\_tokens não pode ser reparada com segurança, então aumente o limite e reenvie. Fora isso, remova code fences e o texto em volta, decodifique o primeiro valor JSON e corrija só erros sem ambiguidade, como vírgulas finais. Valide contra um schema e, se falhar, devolva o erro exato uma ou duas vezes. Saída estruturada evita quase tudo isso onde é suportada.

## Pontos principais

-   A maior parte do JSON quebrado é embrulho, não JSON ruim: uma code fence, uma frase antes ou depois, ou um bloco de raciocínio. O raw\_decode do Python lê o primeiro valor e ignora o resto.
-   finish\_reason "length" significa que o JSON foi cortado. Fechar os colchetes faz o parse funcionar, mas perde dados em silêncio, então reenvie com mais espaço.
-   Corrija só o que tem um único significado: vírgulas finais, True/None no estilo Python e aspas simples. Rejeite todo o resto e peça de novo.
-   O módulo json do Python aceita NaN e Infinity por padrão; a RFC 8259 não. Rejeite-os, senão outros parsers mais adiante vão falhar.
-   Na BroadNet Inference, só o GLM 5.3 e o Qwen3.8 27B documentam saída estruturada. Nos outros modelos, use JSON pedido só no prompt mais este reparo e validação.

**Nesta página**

1.  Por que LLMs retornam JSON inválido?
2.  Por que não reparar JSON truncado?
3.  Uma função de reparo que só corrige os casos seguros
4.  Como fazer retry quando o reparo falha?
5.  Saída estruturada torna isso desnecessário?
6.  Onde a BroadNet Inference se encaixa

Seu código chama `json.loads()` na resposta de um modelo e recebe `JSONDecodeError: Expecting value: line 1 column 1`. Ou o parse funciona, mas um campo vem como string onde você queria um número. Este post organiza as causas pelo que dá para fazer com segurança em cada uma, traz uma função Python testada que repara só os casos sem ambiguidade e mostra um loop de retry que sabe quando uma nova tentativa não vai ajudar.

A escolha entre [JSON mode](https://broadrouter.com/pt/glossary/json-mode/) e `json_schema` está em [JSON mode vs json\_schema](https://broadrouter.com/pt/blog/structured-output-json-schema/). Este post trata do que fazer com a resposta que você de fato recebeu.

## Por que LLMs retornam JSON inválido?

Um modelo escreve texto um token por vez. A menos que o servidor restrinja a decodificação, nada o impede de acrescentar uma frase simpática ou de ficar sem espaço. As falhas mais comuns:

| O que você vê | Causa | Dá para reparar no código com segurança? |
| --- | --- | --- |
| ` ```json ` … ` ``` ` em volta do objeto | Hábito de formatação de chat | Sim: remova a fence |
| “Here is the JSON:” antes, “Let me know…” depois | Mesmo hábito | Sim: leia só o primeiro valor |
| `<think>...</think>` antes do objeto | Texto de raciocínio no campo content em alguns servidores | Sim: remova o bloco |
| Termina no meio de uma string, colchetes abertos | Atingiu `max_tokens` | Não: reenvie com mais espaço |
| Content vazio | O raciocínio usou todo o orçamento | Não: reenvie com mais espaço |
| `{"a": 1,}` | Vírgula final; JavaScript aceita, a [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) não | Sim: um único significado |
| `{'a': True, 'b': None}` | Sintaxe Python | Sim: `ast.literal_eval` lê com segurança |
| `NaN`, `Infinity` | Não é JSON; o Python aceita por padrão | Não: rejeite |
| JSON válido, tipos errados ou campos ausentes | Schema não imposto | Não: peça de novo com o erro |

A linha divisória é a ambiguidade. Se o modelo só poderia ter querido dizer uma coisa, corrija no código e registre que corrigiu. Se você teria que adivinhar, rejeite a resposta.

## Por que não reparar JSON truncado?

Porque a versão reparada parece certa e não está. Rodamos o [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, uma biblioteca popular com licença MIT, em uma resposta cortada no meio de uma palavra:

```text
'{"name": "Omar", "city": "Jed'  ->  {'name': 'Omar', 'city': 'Jed'}
```

Ele retornou JSON válido com a cidade “Jed”. O README dele é franco sobre isso: “automatically completes missing values in JSON fields with reasonable defaults” (tradução: completa automaticamente valores ausentes em campos JSON com padrões razoáveis). Isso é útil para ler logs. Para dados que você armazena ou usa para agir, transforma uma falha visível em uma falha silenciosa.

Confira o `finish_reason` antes do parse. `"length"` significa que a resposta atingiu [`max_tokens`](https://broadrouter.com/pt/glossary/max-tokens/). Reenviar a mesma requisição com o mesmo limite falha do mesmo jeito, então dobre o limite ou peça menos por chamada. Modelos de raciocínio deixam isso mais comum: a [referência da API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-fix-invalid-json-from-llm&utm_content=body) da BroadNet diz que DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam antes de responder, e o raciocínio conta em `max_tokens`. Com um limite pequeno, a resposta pode voltar vazia. Deixe 1.000 tokens ou mais, ou defina `reasoning_effort` como `low`; o [post sobre orçamento de raciocínio](https://broadrouter.com/pt/blog/reasoning-model-max-tokens-budget/) tem os números.

## Uma função de reparo que só corrige os casos seguros

Ela usa só a biblioteca padrão. Retorna o valor parseado e uma lista dos reparos feitos, para você poder contá-los.

```python
import ast, json, re

class Truncated(Exception): pass
class NotJSON(Exception): pass

FENCE = re.compile(r"```(?:json|JSON)?\s*\n(.*?)```", re.S)
THINK = re.compile(r"<think>.*?</think>", re.S)

def _reject_constant(name):                 # NaN, Infinity: Python accepts them, JSON does not
    raise NotJSON(f"non-standard constant {name}")

_decoder = json.JSONDecoder(parse_constant=_reject_constant)

def _first_value(s):
    """Decode the first JSON object or array in s, ignoring prose before and after it."""
    for i, ch in enumerate(s):
        if ch in "{[":
            try:
                return _decoder.raw_decode(s, i)[0]
            except json.JSONDecodeError:
                continue                    # a stray brace in prose; try the next one
    raise NotJSON("no JSON object or array found")

def _scan(s):
    """Drop commas before } or ] outside strings; report brackets left open."""
    out, stack, in_str, esc = [], [], False, False
    for i, ch in enumerate(s):
        if in_str:
            if esc:
                esc = False
            elif ch == "\\":
                esc = True
            elif ch == '"':
                in_str = False
        elif ch == '"':
            in_str = True
        elif ch in "{[":
            stack.append(ch)
        elif ch in "}]" and stack:
            stack.pop()
        elif ch == ",":
            rest = s[i + 1:].lstrip()
            if rest[:1] in ("}", "]"):
                continue                    # trailing comma: skip it
        out.append(ch)
    return "".join(out), len(stack) + (1 if in_str else 0)

def _python_literal(s):
    """Output in Python syntax: single quotes, True/False/None, trailing commas."""
    start = min((i for i in (s.find("{"), s.find("[")) if i >= 0), default=-1)
    end = max(s.rfind("}"), s.rfind("]"))
    if start < 0 or end <= start:
        raise NotJSON("no braces")
    value = ast.literal_eval(s[start:end + 1])       # literals only; never runs code
    if not isinstance(value, (dict, list)):
        raise NotJSON("not an object or array")
    json.dumps(value, allow_nan=False)               # must round-trip as strict JSON
    return value

def parse_llm_json(content, finish_reason=None):
    """Return (value, repairs). Raises Truncated or NotJSON."""
    if finish_reason == "length":
        raise Truncated("hit max_tokens; raise the limit or shorten the output")
    if not content or not content.strip():
        raise NotJSON("empty content (reasoning may have used the whole budget)")
    repairs = []
    s = content.strip().lstrip("\ufeff")
    if THINK.search(s):
        s = THINK.sub("", s).strip(); repairs.append("removed <think> block")
    m = FENCE.search(s)
    if m:
        s = m.group(1).strip(); repairs.append("removed code fence")
    try:
        value = _decoder.decode(s)
        return value, repairs
    except json.JSONDecodeError:
        pass
    try:
        value = _first_value(s); repairs.append("ignored text around JSON")
        return value, repairs
    except NotJSON:
        pass
    fixed, open_count = _scan(s)
    if open_count:
        raise NotJSON(f"incomplete JSON, {open_count} bracket(s) or string left open: treat as truncated")
    if fixed != s:
        try:
            value = _first_value(fixed); repairs.append("removed trailing commas")
            return value, repairs
        except NotJSON:
            pass
    try:
        value = _python_literal(s); repairs.append("parsed Python-style literal")
        return value, repairs
    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError, NotJSON) as e:
        raise NotJSON(f"unrepairable: {e}") from None
```

Como cada etapa funciona:

1.  **Truncamento e respostas vazias** levantam exceção antes de qualquer parse, então nunca viram dados.
2.  **Fences e blocos de raciocínio** são removidos com duas expressões regulares.
3.  **`raw_decode`** é a ferramenta-chave. A documentação do Python diz que ele decodifica um documento “from a string that may have extraneous data at the end” (tradução: de uma string que pode ter dados estranhos no final) e retorna onde parou. Começando no primeiro `{` ou `[`, ele pula o texto antes do objeto e ignora o texto depois. Se uma chave no meio do texto não decodifica, ele tenta a próxima.
4.  **A varredura de colchetes** percorre o texto acompanhando strings e escapes. Colchetes que ficaram abertos significam que a resposta foi cortada mesmo que o `finish_reason` não diga; isso levanta exceção. Vírgulas logo antes de `}` ou `]` fora de strings são removidas.
5.  **`ast.literal_eval`** lê saída no estilo Python com aspas simples, `True` e `None`. Ele só avalia literais e nunca executa código. O resultado depois precisa serializar como JSON estrito.
6.  **`NaN` e `Infinity`** levantam exceção, via `parse_constant`. O `json` do Python os aceita por padrão; a RFC 8259 diz que eles “are not permitted” (tradução: não são permitidos), e o `JSON.parse` do JavaScript os rejeita.

Rodamos a função em 17 strings de teste: JSON limpo, JSON em fence, chaves e valores em árabe dentro de uma fence, texto antes e depois, um placeholder `{name}` no texto antes do objeto, um bloco `<think>`, vírgulas finais em objetos e arrays, vírgulas e colchetes dentro de strings, aspas escapadas, um caminho do Windows terminando em barra invertida, literais Python, `NaN`, uma resposta vazia, uma resposta cortada com e sem `finish_reason: "length"` e dois objetos seguidos. Todas se comportaram como diz a tabela acima. Um teste pegou um bug real: uma versão inicial invertia a flag de escape antes de checar a aspa de fechamento, então `"he said \"hi,]\""` perdia a vírgula. Teste o seu código de reparo com aspas escapadas.

Dois limites para conhecer. Com dois objetos seguidos, ela retorna o primeiro; se você quer vários itens, peça um único array JSON. E saída Python com aspas simples que contém aspas duplas dentro de uma string pode ser mal lida pela varredura de colchetes e rejeitada. Rejeitar é a falha segura.

## Como fazer retry quando o reparo falha?

O reparo cuida do formato. A validação cuida do conteúdo: campos certos, tipos certos, valores plausíveis. Este loop valida com o pacote `jsonschema` e escolhe o retry pela causa:

```python
import json, os
from jsonschema import Draft202012Validator
from openai import OpenAI
from llm_json import parse_llm_json, Truncated, NotJSON

client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
SCHEMA = {"type": "object", "additionalProperties": False,
          "required": ["name", "city", "amount"],
          "properties": {"name": {"type": "string", "minLength": 1},
                         "city": {"type": ["string", "null"]},
                         "amount": {"type": "number", "minimum": 0}}}
validator = Draft202012Validator(SCHEMA)

def extract(text, model="broadnet/qwen3.8-27b", max_tokens=1500, attempts=3, log=print):
    messages = [{"role": "system", "content": "Extract name, city and amount. Reply with one JSON object only, no code fence. "
                                              "Schema: " + json.dumps(SCHEMA)},
                {"role": "user", "content": text}]
    for attempt in range(1, attempts + 1):
        r = client.chat.completions.create(model=model, messages=messages, max_tokens=max_tokens,
                                           reasoning_effort="low", temperature=0)
        c = r.choices[0]
        try:
            value, repairs = parse_llm_json(c.message.content, c.finish_reason)
            errors = [f"{'/'.join(map(str, e.path)) or '(root)'}: {e.message}" for e in validator.iter_errors(value)]
            if not errors:
                log({"attempt": attempt, "repairs": repairs, "ok": True})
                return value
            problem = "The JSON does not match the schema: " + "; ".join(errors)
        except Truncated:
            log({"attempt": attempt, "ok": False, "why": "truncated"})
            max_tokens *= 2                 # same prompt, more room; a re-ask would be cut off too
            continue
        except NotJSON as e:
            problem = f"That reply was not valid JSON ({e})."
        log({"attempt": attempt, "ok": False, "why": problem})
        messages += [{"role": "assistant", "content": c.message.content or ""},
                     {"role": "user", "content": problem + " Return the corrected JSON object only."}]
    raise RuntimeError(f"no valid JSON after {attempts} attempts")
```

As regras desse loop:

-   **Truncado: reenvie as mesmas mensagens com o dobro do limite.** Acrescentar uma mensagem “por favor, corrija” deixaria o prompt maior e a saída nada menor.
-   **Não é JSON, ou formato errado: devolva o erro exato.** “amount: ‘1200’ is not of type ‘number’” dá ao modelo algo específico para corrigir. Um retry sem explicação muitas vezes repete o erro.
-   **Limite a três tentativas.** Cada retry reenvia a conversa inteira como [tokens de entrada](https://broadrouter.com/pt/glossary/input-and-output-tokens/). Depois de três, registre a entrada e encaminhe para outro lugar.
-   **Registre a lista de reparos.** Um aumento de “removed code fence” depois de uma mudança no prompt mostra que o prompt piorou, mesmo sem nenhuma falha.

Rodamos este loop contra um servidor mock local que devolvia respostas roteirizadas. Uma resposta em fence com vírgula final e `"amount": "1200"` como string foi reparada, falhou na validação e foi corrigida na segunda chamada com o erro devolvido. Uma resposta cortada com `finish_reason: "length"` foi reenviada com `max_tokens` aumentado de 1.500 para 3.000 e deu certo. O mock registrou cada requisição, confirmando a quantidade de mensagens e o limite que o loop enviou. Um modelo real pode falhar de outras formas, então rode com 100 entradas suas antes de confiar nos números.

## Saída estruturada torna isso desnecessário?

Elimina a maior parte. Um servidor que restringe a decodificação ao seu schema não consegue emitir uma fence, uma vírgula final ou um campo ausente. O vLLM, um servidor comum de modelos abertos, faz isso com os backends xgrammar ou guidance. Mesmo assim, duas falhas continuam: truncamento em `max_tokens` e recusas. A OpenAI observa que a saída em JSON mode é válida “except for in some edge cases” (tradução: exceto em alguns casos extremos) e que a sua aplicação “must detect and handle” (tradução: deve detectar e tratar) saídas que não sejam um objeto completo. Então mantenha a checagem de `finish_reason` e o validador, mesmo com `json_schema`.

O que cada abordagem evita:

| Abordagem | Fences e texto | Erros de sintaxe | Formato errado | Truncamento |
| --- | --- | --- | --- | --- |
| Só prompt (“responda em JSON”) | Reduz | Reduz | Reduz | Não |
| JSON mode (`json_object`) | Sim | Sim | Não | Não |
| Saída estruturada (`json_schema`, imposta) | Sim | Sim | Sim | Não |

Com JSON mode, a OpenAI também diz que você “must always instruct the model to produce JSON” (tradução: deve sempre instruir o modelo a produzir JSON) em uma mensagem; caso contrário, ele pode emitir espaços em branco até atingir o limite de tokens. Outros servidores compatíveis com a OpenAI variam, então teste o modo no modelo que você vai colocar em produção. O teste está no [post sobre saída estruturada](https://broadrouter.com/pt/blog/structured-output-json-schema/).

Para conferir uma resposta à mão, cole-a no [validador de saída JSON de LLM](https://broadrouter.com/tools/llm-json-output-validator/), ou gere um schema estrito a partir de um objeto de exemplo com o [gerador de JSON schema](https://broadrouter.com/tools/json-schema-generator/).

## Onde a BroadNet Inference se encaixa

O BroadRouter é o site da BroadNet. A referência da API da BroadNet lista saída estruturada só para o [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) e o [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/), e não nomeia o parâmetro da requisição, então teste `json_schema` no modelo antes de depender dele. No [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) e no [Gemma 4 VL 26B](https://broadrouter.com/pt/models/gemma-4-vl-26b/), use JSON pedido no prompt com a função de reparo e o validador acima. Três dos quatro modelos raciocinam antes de responder, então reserve espaço em `max_tokens` para isso. Para extração em lote, o [post sobre o batch runner](https://broadrouter.com/pt/blog/llm-batch-processing-without-batch-api/) mostra como registrar o `finish_reason` de cada item. Prompts e respostas não são retidos depois de cada requisição.

Ferramentas gratuitas sobre o tema (em inglês)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[JSON mode (modo JSON)](https://broadrouter.com/pt/glossary/json-mode/)

JSON mode é uma configuração de APIs de LLM, response\_format {"type": "json\_object"} em APIs no estilo da OpenAI, que faz a resposta do modelo ser JSON válido e parseável. Ao contrário de structured outputs com JSON Schema, ele não garante quais chaves, tipos ou valores o objeto contém.

[Saída estruturada (structured output)](https://broadrouter.com/pt/glossary/structured-output/)

Saída estruturada é um recurso de APIs de LLM que restringe a resposta de um modelo a um formato definido pelo desenvolvedor, normalmente um JSON Schema, para que o código consiga interpretá-la de forma confiável. É mais rigorosa que o JSON mode, que garante um JSON válido, mas não uma estrutura específica.

[JSON Schema](https://broadrouter.com/pt/glossary/json-schema/)

JSON Schema é um vocabulário, escrito em JSON, para descrever e validar a estrutura de dados JSON: tipos, campos obrigatórios, valores permitidos e aninhamento. A versão atual é a 2020-12. APIs de LLM o usam para definir parâmetros de tools e o formato exato que uma saída estruturada deve seguir.

[Prefill e decode](https://broadrouter.com/pt/glossary/prefill-and-decode/)

Prefill e decode são as duas fases da inferência de um LLM. No prefill, o modelo processa o prompt inteiro em paralelo e preenche o KV cache; no decode, gera a resposta um token por vez, reaproveitando esse cache. O prefill define principalmente o tempo até o primeiro token; o decode, a velocidade de saída.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Janela de contexto (context window)](https://broadrouter.com/pt/glossary/context-window/)

A janela de contexto é o número máximo de tokens com que um modelo de linguagem consegue trabalhar em uma única requisição. Ela abrange o prompt, o histórico da conversa, as definições de ferramentas, as imagens e a saída gerada, incluindo os tokens de raciocínio. O que não couber precisa ser cortado, resumido ou dividido em várias requisições.

[Licença do modelo (model license)](https://broadrouter.com/pt/glossary/model-license/)

A licença de um modelo são os termos legais sob os quais os pesos, o código e as saídas de um modelo podem ser usados, alterados e compartilhados. Modelos open-weight usam licenças de software padrão, como Apache 2.0 ou MIT, ou licenças próprias que podem acrescentar condições, como limites para grandes serviços comerciais.

## Perguntas frequentes

### Por que o meu LLM retorna o JSON dentro de um bloco de código markdown?

Modelos de chat costumam formatar código para pessoas, e a code fence é como as interfaces de chat o exibem. Peça "só JSON, sem code fence", mas remova as fences no código mesmo assim: a instrução diminui a frequência, não elimina.

### Como corrigir JSONDecodeError na saída de um LLM?

Olhe primeiro o finish\_reason. Se for "length", a resposta foi cortada: aumente max\_tokens e reenvie. Se não, remova as code fences e decodifique o primeiro valor JSON com raw\_decode, que ignora o texto depois dele. Corrija vírgulas finais e valide. Se ainda falhar, peça de novo passando o erro.

### Devo usar uma biblioteca de reparo de JSON?

Para logs e depuração, sim. Para dados com os quais você vai agir, cuidado. Bibliotecas como json\_repair completam valores ausentes com padrões, então uma cidade truncada "Jed" volta como um "Jed" válido. Rejeite a saída truncada e reenvie.

### Por que a saída JSON do meu LLM vem cortada?

A resposta atingiu max\_tokens. Em modelos de raciocínio como DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B, o raciocínio conta nesse limite, então um raciocínio longo pode deixar pouco espaço. Aumente o limite, defina reasoning\_effort low ou peça menos saída por chamada.

### O JSON mode garante JSON válido?

Quase. A OpenAI diz que a saída em JSON mode é JSON válido "except for in some edge cases" (tradução: exceto em alguns casos extremos), como atingir o limite de tokens, e ele não impõe o seu schema. Saída estruturada com json\_schema adiciona aderência ao schema onde o provedor a impõe. Valide de qualquer forma.

### Quais modelos da BroadNet suportam saída estruturada?

A referência da API da BroadNet lista saída estruturada para GLM 5.3 e Qwen3.8 27B, verificado em 15 de novembro de 2026. Não lista para DeepSeek V4.1 Flash nem para Gemma 4 VL 26B, então nesses use JSON pedido no prompt com reparo e validação.

## Continue lendo

-   [JSON mode vs json\_schema: saída estruturada que não quebra](https://broadrouter.com/pt/blog/structured-output-json-schema/)
-   [Tool calling com modelos abertos: schemas, chamadas paralelas, retry](https://broadrouter.com/pt/blog/tool-calling-open-models/)
-   [Como definir max\_tokens em modelos de raciocínio: um método](https://broadrouter.com/pt/blog/reasoning-model-max-tokens-budget/)
-   [Classificação de texto em árabe com LLM: sentimento, intenção, triagem](https://broadrouter.com/pt/blog/arabic-text-classification-llm/)
-   [Processamento em lote com LLM sem Batch API: um runner retomável](https://broadrouter.com/pt/blog/llm-batch-processing-without-batch-api/)
-   [Traduzir strings de app para árabe com LLM: placeholders e plurais](https://broadrouter.com/pt/blog/translate-app-strings-to-arabic-llm/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: Por que um modelo de raciocínio devolve uma resposta vazia](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/)
-   [Guia: Como usar o SDK Python da OpenAI com a BroadNet Inference](https://broadrouter.com/pt/guides/openai-python-sdk/)
-   [Guia: Ler notas fiscais e recibos em árabe com um modelo de visão](https://broadrouter.com/pt/guides/read-arabic-invoices-with-vision/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-fix-invalid-json-from-llm&utm_content=page-cta) ·

**Fontes**

-   [Referência da API da BroadNet Inference: ferramentas e saída estruturada listadas só para GLM 5.3 e Qwen3.8 27B; DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam, e o raciocínio conta em max\_tokens (verificado em 2026-11-16) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [Guia de Structured Outputs da OpenAI: JSON mode vs aderência ao schema, instruir o modelo a produzir JSON, espaços em branco até o limite de tokens, saída incompleta, recusas (verificado em 2026-11-15)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, The JSON Data Interchange Format: gramática de objetos, strings entre aspas duplas, Infinity e NaN não permitidos (verificado em 2026-11-15)](https://www.rfc-editor.org/rfc/rfc8259)
-   [Documentação do Python, módulo json: JSONDecoder.raw\_decode, NaN e Infinity aceitos por padrão, parse\_constant (verificado em 2026-11-15)](https://docs.python.org/3/library/json.html)
-   [json\_repair no GitHub (MIT): repara JSON malformado e preenche valores ausentes com padrões (versão 0.64.9 testada; verificado em 2026-11-15)](https://github.com/mangiucugna/json_repair)
-   [Documentação do vLLM, structured outputs: json\_schema, regex, choice e grammar com os backends xgrammar ou guidance (verificado em 2026-11-15)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
