Salidas estructuradas: cómo obtener JSON válido de un modelo de lenguaje
ExplicaciónPor Lucas Matías García TorresActualizado el Datos comprobados el 5 min de lectura
Revisado por Lucas Matías García Torres el . Cómo trabajamos.

Respuesta corta
Las salidas estructuradas, a 23 de octubre de 2026, hacen que un modelo devuelva JSON que cumple un esquema definido por ti. OpenAI, Anthropic y Google imponen el esquema mientras el modelo genera (decodificación restringida), y Ollama acepta un esquema en local. Cada API admite solo una parte de JSON Schema: OpenAI exige todos los campos obligatorios y additionalProperties en false, Anthropic permite 24 parámetros opcionales por petición y Gemini ignora minLength y maxLength. Una forma válida no garantiza valores correctos.
Los precios y límites cambian a menudo: compruébalos en la web del proveedor antes de pagar. Cómo nos financiamos.
Las salidas estructuradas hacen que un modelo de lenguaje devuelva JSON que cumple un esquema definido por ti, de modo que tu código puede leer cada respuesta sin reintentos. A 23 de octubre de 2026, OpenAI, Anthropic, Google y Ollama las admiten, y las tres API en la nube imponen el esquema mientras el modelo genera (decodificación restringida), en lugar de limitarse a pedirlo en el prompt. Esta guía explica en qué se diferencian del antiguo modo JSON, cómo se activan en cada API, qué partes de JSON Schema aceptan y qué límites siguen rompiendo proyectos reales, a partir de la documentación de cada fabricante leída el 23 de octubre de 2026.
El modo JSON no es lo mismo
El modo JSON solo promete JSON válido. Las salidas estructuradas prometen JSON que sigue tu esquema: todas las claves obligatorias presentes, cada valor de una lista permitida y cada tipo correcto. OpenAI presenta las salidas estructuradas como la evolución del modo JSON y recomienda usarlas siempre que se pueda. El modo JSON además tiene una trampa: OpenAI avisa de que si olvidas pedirle al modelo que responda en JSON, puede soltar un chorro interminable de espacios en blanco hasta agotar el límite de tokens.
La diferencia se nota en producción. Sin esquema, un modelo puede saltarse un campo, inventarse un valor fuera de tu lista o envolver el JSON en texto, y cualquiera de esas cosas rompe el analizador. Con decodificación restringida, el modelo solo puede elegir tokens que mantengan la salida válida frente al esquema. Anthropic lo resume en que se acaban los errores de JSON.parse() y los reintentos por incumplir el esquema.
Cómo se activan en cada API
Tabla: salidas estructuradas por fabricante (documentación oficial, comprobada el 23 de octubre de 2026)
| Concepto | OpenAI | Anthropic (Claude) | Google (API de Gemini) | Ollama (en local) |
|---|---|---|---|---|
| Parámetro | text.format con type: "json_schema" y strict: true |
output_config.format con type: "json_schema" |
response_format con mime_type: "application/json" y un schema |
format con un esquema JSON (o "json") |
| Cómo se impone | restringida al esquema | decodificación restringida con una gramática compilada | decodificación restringida | el esquema se pasa al modelo |
| Ayudas de los SDK | Pydantic (Python), Zod (JavaScript), Ruby | Pydantic, Zod, C#, Go, Java, PHP, Ruby | Pydantic, Zod | Pydantic, Zod |
| Para entradas de herramientas | llamada a funciones estricta | uso estricto de herramientas (strict: true) |
llamada a funciones | no lo indica |
En las llamadas a herramientas la idea es la misma, aplicada a los argumentos: el modo estricto de OpenAI y el uso estricto de herramientas de Anthropic garantizan que las entradas cumplan el esquema de la herramienta. Nuestra explicación de la llamada a funciones cuenta cuándo debe el modelo llamar a una herramienta en lugar de responder con un formato fijo. La regla de Google es corta: las salidas estructuradas dan formato a la respuesta final y la llamada a funciones ejecuta una acción antes de responder.
En local, Ollama acepta un esquema JSON en su campo format y recomienda poner también el esquema en el prompt y bajar la temperatura a 0. Su documentación indica que la nube de Ollama no admite salidas estructuradas. Si usas modelos en tu propio equipo, nuestra guía para instalar Ollama explica la configuración.
Qué partes de JSON Schema se admiten
Ningún fabricante acepta el estándar JSON Schema completo. Las reglas que más tropiezos causan:
- Todos los campos obligatorios (OpenAI). Todos deben figurar en
required. Para que uno sea opcional, se le da un tipo unión connull. additionalProperties: false. OpenAI lo exige en cada objeto, y Anthropic solo aceptafalse.- Objeto raíz. OpenAI exige que la raíz sea un objeto y no un
anyOf, que es justo lo que produce una unión discriminada de Zod. - Recursividad. OpenAI admite esquemas recursivos; Anthropic los da como no admitidos.
- Restricciones ignoradas. Gemini elimina
minLength,maxLength,minProperties,maxPropertiesyuniqueItemsen lugar de imponerlas; las ayudas del SDK de Anthropic pasan las restricciones no admitidas, comominimum, a la descripción del campo y las comprueban en tu código.
Los límites de tamaño también cambian. OpenAI permite hasta 5.000 propiedades de objeto con hasta 10 niveles de anidación y hasta 1.000 valores de enumeración por esquema. Anthropic limita cada petición a 20 herramientas estrictas, 24 parámetros opcionales y 16 parámetros con tipos unión entre todos los esquemas estrictos, y responde «Schema is too complex for compilation» cuando la gramática sería demasiado grande. Gemini rechaza los esquemas muy grandes o muy anidados con un error 400 INVALID_ARGUMENT.
Latencia, caché y coste
El esquema hay que compilarlo la primera vez. OpenAI indica que la primera petición con un esquema nuevo tarda más y las siguientes no. Anthropic guarda en caché las gramáticas compiladas 24 horas desde su último uso y la invalida cuando cambia la estructura del esquema, pero no cuando solo cambian nombres o descripciones. Cambiar el formato de salida en Claude invalida además la caché de prompts de esa conversación. No hay precio aparte: el JSON se cobra como tokens de salida normales, y OpenAI admite las salidas estructuradas en su Batch API, así que se aplica el 50 % de descuento de la API por lotes.
Qué puede seguir fallando
- Rechazos. Si el modelo se niega por seguridad, OpenAI devuelve un campo
refusalaparte y Claude marcastop_reason: "refusal"; en ambos casos la salida puede no cumplir el esquema. - Respuesta cortada. Si se acaba
max_tokens, el JSON queda incompleto. Sube el límite y repite. - Válido pero falso. El esquema garantiza la forma, no la verdad. OpenAI advierte de que si la entrada no tiene nada que ver con el esquema, el modelo puede rellenarlo con valores inventados, y Google pide validar los valores en tu aplicación. Nuestra guía sobre las alucinaciones de los modelos explica por qué.
- Mayúsculas en las enumeraciones. Anthropic avisa de que Claude puede devolver un valor que solo difiere en mayúsculas. Compara esos valores sin distinguir mayúsculas.
- Funciones incompatibles. En Claude, las salidas estructuradas no se pueden combinar con citas (error 400) ni con el relleno previo del mensaje del asistente.
Una configuración que aguanta
Define el esquema una sola vez en el código con Pydantic o Zod y deja que el SDK genere el JSON Schema, como recomienda OpenAI para que no se desincronicen. Mantén el esquema plano, haz obligatorios los campos que tengan un valor por defecto, describe cada campo en una frase sencilla y dile al modelo qué devolver cuando la entrada no encaje, por ejemplo una lista vacía. Después valida los valores en tu propio código, porque una forma válida es solo la mitad de una respuesta correcta.
Qué hemos comprobado
- OpenAI Structured Outputs garantizan que la respuesta cumple el JSON Schema dado; son la evolución del modo JSON, que solo garantiza JSON válido, y OpenAI recomienda usarlas siempre que se pueda; el modo JSON sin instrucción explícita puede producir espacios en blanco sin fin; todos los campos deben ser obligatorios y los opcionales se emulan con una unión con null; additionalProperties false es obligatorio; la raíz debe ser un objeto y no anyOf; admite esquemas recursivos; hasta 5.000 propiedades de objeto y 10 niveles de anidación, hasta 1.000 valores de enumeración; la primera petición con un esquema tarda más; los rechazos llegan en un campo refusal; admitidas en las API Responses, Chat Completions, Assistants, Fine-tuning y Batch; se recomiendan las ayudas de los SDK para evitar desincronización. (OpenAI, )
- Anthropic, salidas estructuradas: JSON con output_config.format y uso estricto de herramientas con strict: true; decodificación restringida con gramáticas compiladas; latencia de compilación en la primera petición; gramáticas en caché 24 horas desde el último uso, invalidada por cambios de estructura del esquema pero no de nombres o descripciones; cambiar output_config.format invalida la caché de prompts; no admite esquemas recursivos ni additionalProperties distinto de false; límites de 20 herramientas estrictas, 24 parámetros opcionales y 16 parámetros con tipos unión por petición; error «Schema is too complex for compilation»; los rechazos marcan stop_reason refusal; no garantiza las mayúsculas de las enumeraciones; incompatible con citas y con el relleno previo; las ayudas del SDK pasan las restricciones no admitidas a la descripción y validan la respuesta. (Anthropic, )
- API de Gemini, salidas estructuradas: response_format con mime_type application/json y un schema; tipos string, number, integer, boolean, object, array y null; minLength, maxLength, minProperties, maxProperties, uniqueItems, contains, minContains y maxContains se eliminan y no se imponen, mientras que minItems y maxItems sí; los esquemas muy grandes o anidados se rechazan con 400 INVALID_ARGUMENT; las salidas estructuradas dan formato a la respuesta final y la llamada a funciones ejecuta acciones; combinarlas con herramientas integradas es una vista previa para los modelos Gemini 3; hay que validar los valores en la aplicación. (Google, )
- Ollama, salidas estructuradas: se pasa un esquema JSON (o json) en el campo format; conviene poner también el esquema en el prompt; bajar la temperatura a 0 da salidas más deterministas; funciona con la API compatible con OpenAI mediante response_format; la nube de Ollama no las admite. (Ollama, )
Qué puede cambiar
- Las palabras clave de JSON Schema admitidas y los límites de complejidad cambian cuando los fabricantes actualizan modelos y API. Esta página se revisa cada trimestre.
- Los consejos de la última sección son recomendación nuestra basada en las guías de los fabricantes, no un requisito de ellos.
Preguntas frecuentes
¿Qué son las salidas estructuradas?
Una función que obliga a un modelo de lenguaje a devolver JSON que cumple un esquema que le das, con todas las claves obligatorias y cada valor del tipo correcto. OpenAI, Anthropic y Google imponen el esquema mientras generan, así que la salida siempre se puede leer y sigue la forma del esquema.
¿Qué diferencia hay entre el modo JSON y las salidas estructuradas?
El modo JSON solo garantiza JSON válido; las salidas estructuradas garantizan además que siga tu esquema. OpenAI las presenta como la evolución del modo JSON y recomienda usarlas siempre que se pueda, y avisa de que el modo JSON sin una instrucción explícita puede producir espacios en blanco sin fin.
¿Las salidas estructuradas cuestan más?
No hay tarifa aparte: el JSON se cobra como tokens de salida normales. La primera petición con un esquema nuevo tarda más mientras se compila; Anthropic guarda los esquemas compilados 24 horas desde su último uso, y OpenAI las admite en su Batch API con el descuento por lotes.
¿Por qué mi esquema devuelve un error 400?
Porque usa una función de JSON Schema no admitida o es demasiado complejo. OpenAI exige additionalProperties en false y todos los campos obligatorios, Anthropic limita cada petición a 24 parámetros opcionales y 16 con tipos unión entre los esquemas estrictos, y Gemini rechaza los esquemas muy grandes o anidados.
¿Pueden estar mal las salidas estructuradas?
Sí. Garantizan el formato, no los datos. Un modelo puede rellenar un esquema válido con valores inventados, sobre todo si la entrada no encaja con la tarea, y un rechazo o el límite de tokens pueden dejar la salida incompleta. Valida los valores en tu propio código.
Fuentes
- Structured model outputs (OpenAI API guide): JSON Schema adherence, JSON mode, supported schemas, limits and refusals, OpenAI. Consultado el 23 de octubre de 2026.
- Structured outputs with Claude: JSON outputs, strict tool use, grammar caching, schema limits and incompatibilities, Anthropic. Consultado el 23 de octubre de 2026.
- Structured outputs with the Gemini API: JSON Schema support, unenforced constraints and limitations, Google. Consultado el 23 de octubre de 2026.
- Structured Outputs (Ollama documentation): the format field, schemas and tips, Ollama. Consultado el 23 de octubre de 2026.
¿Has visto un error o un dato desactualizado? Avísanos y lo corregimos.
Historial de cambios
- : Primera publicación. Comprobada el 23 de octubre de 2026 con la guía de salidas estructuradas de OpenAI, la página de salidas estructuradas de Anthropic, la guía de salida estructurada de Gemini y la documentación de salidas estructuradas de Ollama.
Próxima revisión: .
Más guías de APIs de modelos y costes.
Sigue leyendo
- Llamada a funciones: cómo usa un modelo de lenguaje tus herramientas
Llamada a funciones explicada: cómo pide un modelo a tu código que ejecute una herramienta, los ajustes de OpenAI, Anthropic y Google, su coste y cuántas usar.
- API por lotes: cómo pagar la mitad por las peticiones que pueden esperar
Cómo funcionan las API por lotes de OpenAI, Claude, Gemini y Mistral: el 50 % de descuento, plazos de 24 horas, límites de tamaño y cuándo no conviene un lote.
- Caché de prompts explicada: cómo funciona y cuánto ahorra
Qué es la caché de prompts, cómo la aplican OpenAI, Anthropic, Google y DeepSeek, mínimos, duración, precios y cómo estructurar prompts para bajar tu factura.
- Alucinaciones de los modelos: por qué ocurren y cómo reducirlas
Qué son las alucinaciones de los modelos, por qué los modelos se inventan cosas (el entrenamiento y la puntuación premian adivinar) y cómo reducirlas.
- Qué es un token en un modelo de lenguaje
Qué es un token en un modelo de lenguaje, a cuántas palabras equivale, por qué el español usa más tokens que el inglés (lo medimos) y cómo se cobran.
- Cómo instalar Ollama y usar modelos en local, paso a paso
Instala Ollama paso a paso en Windows 10 y 11, Mac o Linux, guarda los modelos en otro disco, elige uno que quepa en tu memoria y conéctalo a otras apps.
Otros temas

Asistentes y chatbots
16 guías

Agentes y automatización
8 guías

Modelos en local
11 guías

Modelos explicados
14 guías