---
title: "JSON inválido de un LLM: causas, reparación y reintento"
description: "Por qué un LLM devuelve JSON roto (bloques de código, texto extra, cortes por max_tokens, comas finales) y una función Python probada que solo repara lo seguro."
url: https://broadrouter.com/es/blog/fix-invalid-json-from-llm/
lang: es
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/fix-invalid-json-from-llm/) (actualizado el 2026-11-16).

# Cómo corregir JSON inválido de un LLM: causas, reparación y reintento

Por el equipo de BroadNet Inference · 7 min de lectura · Publicado 2026-11-15 · Actualizado 2026-11-16

Revise primero finish\_reason: una respuesta cortada en max\_tokens no se puede reparar con seguridad, así que suba el límite y reenvíe. Si no, quite los bloques de código y el texto alrededor, decodifique el primer valor JSON y corrija solo errores inequívocos, como las comas finales. Valide contra un esquema y, si falla, devuelva el error exacto una o dos veces. La salida estructurada evita casi todo esto donde se admite.

## Puntos clave

-   Casi todo el JSON roto es un problema de envoltorio, no de JSON: un bloque de código, una frase antes o después, o un bloque de razonamiento. raw\_decode de Python lee el primer valor e ignora el resto.
-   finish\_reason "length" significa que el JSON se cortó. Cerrar las llaves hace que se pueda analizar, pero pierde datos en silencio; mejor reenvíe con más espacio.
-   Corrija solo lo que tiene un único significado: comas finales, True/None al estilo de Python y comillas simples. Rechace todo lo demás y vuelva a pedirlo.
-   El módulo json de Python acepta NaN e Infinity por defecto; el RFC 8259 no. Recháselos, o fallarán otros analizadores más adelante.
-   En BroadNet Inference, solo GLM 5.3 y Qwen3.8 27B documentan salida estructurada. En los demás modelos, use JSON pedido en el prompt más esta reparación y validación.

**En esta página**

1.  ¿Por qué los LLM devuelven JSON inválido?
2.  ¿Por qué no reparar el JSON truncado?
3.  Una función de reparación que solo corrige los casos seguros
4.  ¿Cómo reintentar cuando la reparación falla?
5.  ¿La salida estructurada hace todo esto innecesario?
6.  Dónde encaja BroadNet Inference

Su código llama a `json.loads()` sobre la respuesta de un modelo y obtiene `JSONDecodeError: Expecting value: line 1 column 1`. O se analiza bien, pero un campo es una cadena donde usted quería un número. Este artículo ordena las causas según lo que se puede hacer con seguridad en cada caso, ofrece una función de Python probada que repara solo los casos inequívocos y muestra un bucle de reintento que sabe cuándo reintentar no sirve de nada.

Cómo elegir entre el [modo JSON](https://broadrouter.com/es/glossary/json-mode/) y `json_schema` se explica en [modo JSON frente a json\_schema](https://broadrouter.com/es/blog/structured-output-json-schema/). Este artículo trata de qué hacer con la respuesta que realmente recibió.

## ¿Por qué los LLM devuelven JSON inválido?

Un modelo escribe el texto token a token. Salvo que el servidor restrinja la decodificación, nada le impide añadir una frase amable o quedarse sin espacio. Los fallos habituales:

| Lo que ve | Causa | ¿Se puede reparar con seguridad en código? |
| --- | --- | --- |
| ` ```json ` … ` ``` ` alrededor del objeto | Costumbre de formato del chat | Sí: quite el bloque |
| “Here is the JSON:” antes, “Let me know…” después | La misma costumbre | Sí: lea solo el primer valor |
| `<think>...</think>` antes del objeto | Texto de razonamiento en el campo de contenido en algunos servidores | Sí: elimine el bloque |
| Termina a mitad de una cadena, con llaves abiertas | Llegó a `max_tokens` | No: reenvíe con más espacio |
| Contenido vacío | El razonamiento agotó todo el presupuesto | No: reenvíe con más espacio |
| `{"a": 1,}` | Coma final; JavaScript la permite, el [RFC 8259](https://www.rfc-editor.org/rfc/rfc8259) no | Sí: un solo significado |
| `{'a': True, 'b': None}` | Sintaxis de Python | Sí: `ast.literal_eval` lo lee con seguridad |
| `NaN`, `Infinity` | No es JSON; Python los acepta por defecto | No: rechace |
| JSON válido, con tipos erróneos o campos que faltan | Esquema no impuesto | No: vuelva a pedirlo con el error |

La línea divisoria es la ambigüedad. Si solo hay una cosa que el modelo pudo querer decir, corríjala en código y registre que lo hizo. Si tendría que adivinar, rechace la respuesta.

## ¿Por qué no reparar el JSON truncado?

Porque la versión reparada parece correcta y no lo es. Ejecutamos [json\_repair](https://github.com/mangiucugna/json_repair) 0.64.9, una biblioteca popular con licencia MIT, sobre una respuesta cortada a mitad de palabra:

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

Devolvió JSON válido con la ciudad “Jed”. Su README lo dice abiertamente: “automatically completes missing values in JSON fields with reasonable defaults” (Traducción: «completa automáticamente los valores faltantes en los campos JSON con valores por defecto razonables»). Eso es útil para leer registros. Para datos que usted guarda o con los que actúa, convierte un fallo visible en uno silencioso.

Revise `finish_reason` antes de analizar. `"length"` significa que la respuesta llegó a [`max_tokens`](https://broadrouter.com/es/glossary/max-tokens/). Reenviar la misma petición con el mismo límite falla igual, así que duplique el límite o pida menos por llamada. Los modelos de razonamiento lo hacen más frecuente: la [referencia de la API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-fix-invalid-json-from-llm&utm_content=body) de BroadNet indica que DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder y que el razonamiento cuenta dentro de `max_tokens`. Con un límite pequeño, la respuesta puede volver vacía. Deje 1,000 tokens o más, o ponga `reasoning_effort` en `low`; [el artículo sobre el presupuesto de razonamiento](https://broadrouter.com/es/blog/reasoning-model-max-tokens-budget/) tiene las cifras.

## Una función de reparación que solo corrige los casos seguros

Usa solo la biblioteca estándar. Devuelve el valor analizado y una lista de las reparaciones que hizo, para que pueda contarlas.

```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
```

Cómo funciona cada paso:

1.  **El truncado y las respuestas vacías** lanzan una excepción antes de analizar nada, así que nunca se convierten en datos.
2.  **Los bloques de código y de razonamiento** se eliminan con dos expresiones regulares.
3.  **`raw_decode`** es la herramienta clave. La documentación de Python dice que decodifica un documento “from a string that may have extraneous data at the end” (Traducción: «a partir de una cadena que puede tener datos sobrantes al final») y devuelve dónde se detuvo. Empezando en el primer `{` o `[`, salta el texto anterior al objeto e ignora el posterior. Si una llave que aparece en el texto no se puede decodificar, prueba con la siguiente.
4.  **El recorrido de llaves** avanza por el texto siguiendo cadenas y escapes. Las llaves que quedan abiertas indican que la respuesta se cortó aunque `finish_reason` no lo dijera, y eso lanza una excepción. Las comas justo antes de `}` o `]` fuera de las cadenas se eliminan.
5.  **`ast.literal_eval`** lee salida al estilo de Python con comillas simples, `True` y `None`. Solo evalúa literales y nunca ejecuta código. Después, el resultado debe poder serializarse como JSON estricto.
6.  **`NaN` e `Infinity`** lanzan una excepción mediante `parse_constant`. El `json` de Python los acepta por defecto; el RFC 8259 dice que “are not permitted” (Traducción: «no están permitidos»), y el `JSON.parse` de JavaScript los rechaza.

La probamos con 17 cadenas de prueba: JSON limpio, JSON en un bloque de código, claves y valores en árabe dentro de un bloque, texto antes y después, un marcador `{name}` en el texto previo al objeto, un bloque `<think>`, comas finales en objetos y arrays, comas y llaves dentro de cadenas, comillas escapadas, una ruta de Windows que termina en barra invertida, literales de Python, `NaN`, una respuesta vacía, una respuesta cortada con y sin `finish_reason: "length"`, y dos objetos seguidos. Todas se comportaron como indica la tabla anterior. Una prueba detectó un error real: una versión temprana cambiaba su indicador de escape antes de comprobar la comilla de cierre, así que `"he said \"hi,]\""` perdía su coma. Pruebe su propio código de reparación con comillas escapadas.

Hay dos límites que conviene conocer. Con dos objetos seguidos, devuelve el primero; si quiere varios elementos, pida un único array JSON. Y la salida de Python con comillas simples que contiene una comilla doble dentro de una cadena puede confundir al recorrido de llaves y acabar rechazada. Rechazar es el fallo seguro.

## ¿Cómo reintentar cuando la reparación falla?

La reparación se ocupa del formato. La validación se ocupa del contenido: los campos correctos, los tipos correctos, valores razonables. Este bucle valida con el paquete `jsonschema` y elige el reintento según la 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")
```

Las reglas de ese bucle:

-   **Truncado: reenvíe los mismos mensajes con el doble de límite.** Añadir un mensaje de «por favor, corríjalo» alargaría el prompt sin acortar la salida.
-   **No es JSON, o tiene la forma equivocada: devuelva el error exacto.** “amount: ‘1200’ is not of type ‘number’” le da al modelo algo concreto que corregir. Un reintento sin más a menudo repite el error.
-   **Limite los intentos a tres.** Cada reintento reenvía toda la conversación como [tokens de entrada](https://broadrouter.com/es/glossary/input-and-output-tokens/). Después de tres, registre la entrada y derívela a otro proceso.
-   **Registre la lista de reparaciones.** Si tras un cambio de prompt sube el número de “removed code fence”, el prompt ha empeorado, aunque nada haya fallado.

Ejecutamos este bucle contra un servidor simulado local que devolvía respuestas predefinidas. Una respuesta en un bloque de código con una coma final y `"amount": "1200"` como cadena se reparó, falló la validación y se corrigió en la segunda llamada tras devolver el error. Una respuesta cortada con `finish_reason: "length"` se reenvió con `max_tokens` subido de 1,500 a 3,000 y funcionó. El simulador registró la petición cada vez, lo que confirmó el número de mensajes y el límite que envió el bucle. Un modelo real puede fallar de otra forma, así que pruébelo con 100 de sus propias entradas antes de fiarse de las cifras.

## ¿La salida estructurada hace todo esto innecesario?

Elimina la mayor parte. Un servidor que restringe la decodificación a su esquema no puede emitir un bloque de código, una coma final ni un campo faltante. vLLM, un servidor habitual para modelos abiertos, lo hace con los backends xgrammar o guidance. Aun así quedan dos fallos: el truncado en `max_tokens` y los rechazos. OpenAI señala que la salida del modo JSON es válida “except for in some edge cases” (Traducción: «salvo en algunos casos límite») y que su aplicación “must detect and handle” (Traducción: «debe detectar y gestionar») la salida que no sea un objeto completo. Así que mantenga la comprobación de `finish_reason` y el validador, incluso con `json_schema`.

Lo que evita cada enfoque:

| Enfoque | Bloques de código y texto extra | Errores de sintaxis | Forma equivocada | Truncado |
| --- | --- | --- | --- | --- |
| Solo el prompt (“reply with JSON”) | Se reducen | Se reducen | Se reduce | No |
| Modo JSON (`json_object`) | Sí | Sí | No | No |
| Salida estructurada (`json_schema`, impuesta) | Sí | Sí | Sí | No |

Con el modo JSON, OpenAI también dice que usted “must always instruct the model to produce JSON” (Traducción: «debe indicar siempre al modelo que produzca JSON») en algún mensaje; si no, puede emitir espacios en blanco hasta llegar al límite de tokens. Otros servidores compatibles con OpenAI varían, así que pruebe el modo con el modelo que vaya a poner en producción. La prueba está en [el artículo sobre salida estructurada](https://broadrouter.com/es/blog/structured-output-json-schema/).

Para revisar una respuesta a mano, péguela en el [validador de salida JSON de LLM](https://broadrouter.com/tools/llm-json-output-validator/), o genere un esquema estricto a partir de un objeto de ejemplo con el [generador de JSON Schema](https://broadrouter.com/tools/json-schema-generator/).

## Dónde encaja BroadNet Inference

BroadRouter es el sitio web de BroadNet. La referencia de la API de BroadNet lista salida estructurada solo para [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) y [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/), y no nombra el parámetro de la petición, así que pruebe `json_schema` con el modelo antes de depender de él. En [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) y [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/), use JSON pedido en el prompt con la función de reparación y el validador anteriores. Tres de los cuatro modelos razonan antes de responder, así que reserve `max_tokens` para ello. Para extracción masiva, el [artículo sobre el ejecutor por lotes](https://broadrouter.com/es/blog/llm-batch-processing-without-batch-api/) muestra cómo registrar `finish_reason` por elemento. Los prompts y las respuestas no se conservan después de cada petición.

Herramientas gratuitas sobre este tema (en 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.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

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

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

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

El modo JSON (JSON mode) es un ajuste de las APIs de LLM, response\_format {"type": "json\_object"} en las APIs al estilo de OpenAI, que hace que la respuesta del modelo sea JSON válido y procesable. A diferencia de la salida estructurada con un JSON Schema, no garantiza qué claves, tipos o valores contiene el objeto.

[Salida estructurada (structured output)](https://broadrouter.com/es/glossary/structured-output/)

La salida estructurada es una función de las APIs de LLM que restringe la respuesta del modelo a un formato que define el desarrollador, normalmente un JSON Schema, para que el código pueda procesarla de forma fiable. Es más estricta que JSON mode, que garantiza JSON válido pero no una forma concreta.

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

JSON Schema es un vocabulario, escrito en JSON, para describir y validar la estructura de datos JSON: tipos, campos obligatorios, valores permitidos y anidamiento. La versión actual es la 2020-12. Las APIs de LLM lo usan para definir los parámetros de las herramientas y la forma exacta que debe seguir una salida estructurada.

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Prefill y decode (fases de inferencia de un LLM)](https://broadrouter.com/es/glossary/prefill-and-decode/)

Prefill y decode son las dos fases de la inferencia de un LLM. En el prefill, el modelo procesa todo el prompt en paralelo y llena su caché KV; en el decode, genera la respuesta token a token reutilizando esa caché. El prefill determina sobre todo el tiempo hasta el primer token; el decode, la velocidad de salida.

[Licencia de modelo (model license)](https://broadrouter.com/es/glossary/model-license/)

La licencia de un modelo son los términos legales bajo los que se pueden usar, modificar y compartir sus pesos, su código y sus salidas. Los modelos de pesos abiertos usan licencias de software estándar como Apache 2.0 o MIT, o licencias propias que pueden añadir condiciones, como límites a grandes servicios comerciales.

[max\_tokens (límite de tokens de salida)](https://broadrouter.com/es/glossary/max-tokens/)

max\_tokens es un parámetro de las APIs de LLM que fija el máximo de tokens que un modelo puede generar en una respuesta. Cuando la generación llega al límite, se detiene y la respuesta queda marcada como cortada, por ejemplo con finish\_reason en "length".

## Preguntas frecuentes

### ¿Por qué mi LLM devuelve el JSON dentro de un bloque de código markdown?

Los modelos de chat suelen formatear el código para personas, y un bloque de código es como lo muestran las interfaces de chat. Pida «solo JSON, sin bloque de código», pero quite los bloques en el código de todos modos: la instrucción reduce la frecuencia, no la elimina.

### ¿Cómo soluciono un JSONDecodeError en la salida de un LLM?

Mire primero finish\_reason. Si es "length", la respuesta se cortó: suba max\_tokens y reenvíe. Si no, quite los bloques de código y decodifique el primer valor JSON con raw\_decode, que ignora el texto que va detrás. Corrija las comas finales y valide. Si sigue fallando, vuelva a pedirlo con el error.

### ¿Debo usar una biblioteca de reparación de JSON?

Para registros y depuración, sí. Para datos con los que va a actuar, con cuidado. Bibliotecas como json\_repair completan los valores faltantes con valores por defecto, así que una ciudad cortada, "Jed", vuelve como un "Jed" válido. Rechace la salida truncada y reenvíe.

### ¿Por qué se corta la salida JSON de mi LLM?

La respuesta llegó a max\_tokens. En modelos de razonamiento como DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B, el razonamiento cuenta dentro de ese límite, así que pensar mucho puede dejar poco espacio. Suba el límite, ponga reasoning\_effort en low o pida menos salida por llamada.

### ¿El modo JSON garantiza JSON válido?

Casi. OpenAI dice que la salida del modo JSON es JSON válido "except for in some edge cases" (Traducción: «salvo en algunos casos límite»), como alcanzar el límite de tokens, y no impone su esquema. La salida estructurada con json\_schema añade la adherencia al esquema donde el proveedor la aplica. Valide en ambos casos.

### ¿Qué modelos de BroadNet admiten salida estructurada?

La referencia de la API de BroadNet lista salida estructurada para GLM 5.3 y Qwen3.8 27B, según la consulta del 15 de noviembre de 2026. No la lista para DeepSeek V4.1 Flash ni Gemma 4 VL 26B, así que en esos use JSON pedido en el prompt con reparación y validación.

## Siga leyendo

-   [Modo JSON o json\_schema: salida estructurada que no falla](https://broadrouter.com/es/blog/structured-output-json-schema/)
-   [Tool calling con modelos abiertos: esquemas, paralelismo, reintentos](https://broadrouter.com/es/blog/tool-calling-open-models/)
-   [Cómo configurar max\_tokens en modelos de razonamiento: un método](https://broadrouter.com/es/blog/reasoning-model-max-tokens-budget/)
-   [Clasificar texto en árabe con un LLM: sentimiento, intención, triaje](https://broadrouter.com/es/blog/arabic-text-classification-llm/)
-   [Procesamiento por lotes con LLM sin Batch API: un runner reanudable](https://broadrouter.com/es/blog/llm-batch-processing-without-batch-api/)
-   [Traducir textos de apps al árabe con un LLM: placeholders y plurales](https://broadrouter.com/es/blog/translate-app-strings-to-arabic-llm/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: Lea facturas y recibos en árabe con un modelo de visión](https://broadrouter.com/es/guides/read-arabic-invoices-with-vision/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

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

**Fuentes**

-   [Referencia de la API de BroadNet Inference: herramientas y salida estructurada indicadas solo para GLM 5.3 y Qwen3.8 27B; DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan, y el razonamiento cuenta dentro de max\_tokens (consultado el 2026-11-16) (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-fix-invalid-json-from-llm&utm_content=sources)
-   [Guía de Structured Outputs de OpenAI: modo JSON frente a adherencia al esquema, indicar al modelo que produzca JSON, espacios en blanco hasta el límite de tokens, salida incompleta, rechazos (consultado el 2026-11-15)](https://developers.openai.com/api/docs/guides/structured-outputs)
-   [IETF RFC 8259, The JSON Data Interchange Format: gramática de objetos, cadenas entre comillas dobles, Infinity y NaN no permitidos (consultado el 2026-11-15)](https://www.rfc-editor.org/rfc/rfc8259)
-   [Documentación de Python, módulo json: JSONDecoder.raw\_decode, NaN e Infinity aceptados por defecto, parse\_constant (consultado el 2026-11-15)](https://docs.python.org/3/library/json.html)
-   [json\_repair en GitHub (MIT): repara JSON mal formado y rellena valores faltantes con valores por defecto (versión 0.64.9 probada; consultado el 2026-11-15)](https://github.com/mangiucugna/json_repair)
-   [Documentación de vLLM, salidas estructuradas: json\_schema, regex, choice y grammar con los backends xgrammar o guidance (consultado el 2026-11-15)](https://docs.vllm.ai/en/latest/features/structured_outputs.html)
