How Openai Implements Structured Outputs Newtuple Com

Emily Johnson

-Mar 12, 2026, 12:05 PM

how openai implements structured outputs newtuple com

OpenAI has introduced a new feature in their API that allows developers to enforce specific JSON schemas for model responses.This includes a 'strict' mode for function calling and a new 'response_format' parameter. Generating structured data from unstructured input is one of the a key use of AI in today's application. Developers often use the OpenAI API to build powerful tools that can fetch data, answer questions through function calls, organize data for entry, and build complex multi-step agentic workflows that allow LLMs to take... Previously, developers faced challenges due to the basic limitations of language models. They would use various open source tools, craft careful prompts, and frequently resend requests to make sure the outputs from the models matched the needed formats for their systems to work well together. Structured Outputs tackles these issues by forcing OpenAI models to stick to the formats developers provide and by training our models to better understand and handle complex formats.

The way they have achieved this is very interesting, read on for the implementation and in-depth explanation of their approach. Developers can now easily integrate schemas by using Pydantic or Zod objects. These SDKs automatically convert the specified data types into compatible JSON schemas, deserialize JSON responses into structured data formats, and handle any refusals seamlessly. OpenAI used a two part approach for this. They initially trained their latest model, gpt-4o-2024-08-06, to accurately understand and generate outputs based on complex schemas. Despite reaching a 93% benchmark score, the model wasn’t reliable enough for robust applications.

Thus, they adopted a deterministic engineering approach called Constraint Decoding to tighten output restrictions, achieving 100% reliability. JSON is one of the most widely used formats in the world for applications to exchange data. Structured Outputs is a feature that ensures the model will always generate responses that adhere to your supplied JSON Schema, so you don’t need to worry about the model omitting a required key, or... Some benefits of Structured Outputs include: In addition to supporting JSON Schema in the REST API, the OpenAI SDKs for Python and JavaScript also make it easy to define object schemas using Pydantic and Zod respectively. Below, you can see how to extract information from unstructured text that conforms to a schema defined in code.

Structured Outputs is available in our latest large language models, starting with GPT-4o. Older models like gpt-4-turbo and earlier may use JSON mode instead. In the realm of AI-driven applications, ensuring consistent and predictable outputs is paramount. OpenAI’s introduction of Structured Outputs addresses this need by allowing developers to define the exact format of the model’s responses, ensuring they adhere to specified schemas. Structured Outputs enable developers to constrain the model’s responses to a predefined structure, typically defined using JSON Schema. This ensures that the outputs are not only valid JSON but also match the expected format, reducing the need for post-processing and error handling.

🔧 Using pydanticmodel with text_format under the method called client.responses.parse Step 1: Define the pydantic model in models/document_extraction.py Step 2: Create a main.py and run the following code. You will have the structured output in JSON format. OpenAI’s Structured Outputs fundamentally change how developers build reliable applications on top of large language models. Instead of coaxing models with elaborate prompts to “return valid JSON,” you can now guarantee that responses conform to a precise JSON Schema or typed model, drastically reducing parsing errors, retries, and brittle post-processing.[1][2][7]

This article explains very detailed structured outputs with OpenAI: what they are, how they differ from older patterns (like plain JSON mode), how to design robust schemas, integration patterns (Node, Python, Azure OpenAI, LangChain,... Structured Outputs are an OpenAI API feature that ensures model responses always match a supplied JSON Schema, or equivalent type definition, when strict: true is enabled.[1][2][7] This is unlike earlier approaches where you had to parse free-form text or rely only on “valid JSON” promises. OpenAI’s evolution of output control can be summarized as: Developers have long wrestled with the limitations of language models, particularly when ensuring that outputs consistently meet the specific data formats required for integration with their systems. They often had to employ a combination of open-source tools, precise prompting, and repeated adjustments.

In response to these challenges, OpenAI has introduced a new feature in their API that allows developers to enforce specific JSON schemas for model responses. With the new Structured Outputs feature, GPT-4o-2024-08-06 has demonstrated a remarkable 100% reliability in evaluations, perfectly matching the defined output schemas. Click below to learn how you can use this in your workflow and the in-depth explanation of their approach. https://lnkd.in/djBHSfdA Large language models are remarkably capable at reading and understanding documents. Take a photo of a receipt or a scanned invoice, and it will tell you everything on it - the vendor name, the line items, the total, the tax.

The problem is that it will tell you in prose. And prose, however accurate, is not something you can easily load into a database, compare against a ground truth label, or use to compute an F1 score. This was exactly the challenge we ran into in the FewTuRe research project, which dealt with few-shot fine-tuning for information extraction from receipts and invoices. We needed the model to extract structured information from documents, but we also needed that information to reliably arrive in a machine-readable format that matched our ground truth data schema exactly. A response that put the total under "total_amount" one time and "total" the next time was just as useless to our evaluation pipeline as a wrong answer. Consistency wasn't a nice-to-have.

It was a hard requirement. That experience made one thing very clear to us: getting the right answer is only half the problem. Getting it in the right shape is the other half. This post is about solving that second half. We'll walk through how OpenAI's structured outputs feature, combined with Pydantic and the OpenAI Python SDK, gives you a reliable and elegant way to enforce exactly the output format your application needs. To understand why structured outputs matter, it helps to think about what LLMs actually produce by default: a stream of tokens that form natural language text.

Even when you prompt a model to "return a JSON object", you are essentially asking it nicely. There is no guarantee. In practice, this means you get responses like: Master OpenAI Structured Outputs: JSON mode, function calling, and response formatting. Reliable data extraction with guaranteed schema compliance. GPT-5.2 has fundamentally changed how we think about structured outputs.

With the new Context-Free Grammar (CFG) engine, the model literally cannot generate tokens that violate your schema - it's not a suggestion, it's an enforcement mechanism at the token generation level. Combined with the Responses API (the new open-source standard replacing Assistants API) and the Agents SDK for multi-agent workflows, structured outputs have evolved from a reliability feature into the type system for AI-powered applications. The paradigm has shifted to "Schema-First Development." Rather than prompting for JSON and hoping, you define schemas in Zod (TypeScript) or Pydantic (Python) first, then build prompts around them. GPT-5.2's "Thinking" mode reduces hallucinations by 30%, and complex JSON reliability has jumped from ~82% in 5.1 to over 92% in 5.2. The 16k output token limit for structured responses enables extraction of complex nested documents that were previously very difficult. This guide covers production patterns for 2026.

Structured Outputs is an OpenAI feature that constrains model responses to match a predefined JSON schema. When enabled, the model cannot produce output that violates your schema, meaning every required field will be present, every type will be correct, and every enum value will be valid. This is fundamentally different from asking the model to produce JSON in your prompt, which only works most of the time. With structured outputs, schema compliance is enforced at the API level. The evolution toward structured outputs reflects a maturing understanding of how LLMs fit into software systems. Early integrations treated models as text generators, parsing their output with regex and hoping for consistency.

JSON mode improved reliability by ensuring valid JSON syntax, but schemas could still vary between calls. Structured outputs represent the final step: the model becomes a typed function that accepts natural language and returns predictable data structures. We’re so glad you’re here. You can expect all the best TNS content to arrive Monday through Friday to keep you on top of the news and at the top of your game. Check your inbox for a confirmation email where you can adjust your preferences and even join additional groups. Follow TNS on your favorite social media networks.

Check out the latest featured and trending stories while you wait for your first TNS newsletter. OpenAI’s new Structured Outputs feature is designed to ensure that model-generated outputs exactly match JSON schemas that you provide. This feature is particularly beneficial for developers who need consistent and structured data formats, whether for API integration, data processing or application development.

How Openai Implements Structured Outputs Newtuple Com

People Also Search

OpenAI Has Introduced A New Feature In Their API That

The Way They Have Achieved This Is Very Interesting, Read

Thus, They Adopted A Deterministic Engineering Approach Called Constraint Decoding

Structured Outputs Is Available In Our Latest Large Language Models,

🔧 Using Pydanticmodel With Text_format Under The Method Called Client.responses.parse