Intermediate4 min read

Structured Output

Structured output constrains a model to return data in a defined format, such as JSON, instead of free-form text.

Prerequisites

Prompt

What Is Structured Output?

By default, a language model produces free-form text — great for a chat reply, unreliable if you need to parse the result programmatically. Structured output constrains what the model returns to a defined shape, most commonly JSON matching a specific schema, so an application can reliably parse the result without guessing at formatting.

Prompt + Schema

Defines Shape

Constrains the output before generation even starts.

given to

Model

Constrained

Not free-form text, matching the schema instead.

produces

Structured Response

Predictable Format

Most commonly JSON matching a specific schema.

read by

Parsed by Application

Reliable to Consume

No guessing at formatting.

Key Idea

Structured output turns a model's response from something a human reads into something a program can safely consume.

How It Works

Prompt-based — instructing the model in the prompt to respond only in JSON matching a described shape. Simple, but the model can still occasionally deviate from the format.
Schema-constrained generation — some providers let you pass a formal schema (like JSON Schema) that the model's output is directly constrained to match at generation time, making format violations far less likely.
Function/tool-calling style output — many providers implement structured output through the same mechanism used for function calling, since both need the model to produce validated, structured arguments.

Warning

Even with structured output, the application should still validate the result before using it — a technically well-formed JSON object can still contain wrong or hallucinated values.

Code Example

Illustrative pseudocode — the exact schema mechanism varies by provider and SDK:

structured_output_example.py (illustrative pseudocode)

schema = {
    "type": "object",
    "properties": {
        "category": {"type": "string", "enum": ["Billing", "Technical", "Account"]},
        "summary": {"type": "string"},
        "urgent": {"type": "boolean"},
    },
    "required": ["category", "summary", "urgent"],
}

response = client.generate(
    prompt=f"Classify this support ticket: {ticket_text}",
    response_schema=schema,
)

ticket = json.loads(response.text)
assert ticket["category"] in {"Billing", "Technical", "Account"}

Common Mistakes

Trusting structured output without validating it
Well-formed JSON can still contain incorrect or fabricated values — parse and validate, don't just trust the shape.
Relying only on prompt instructions for strict formatting needs
Prompt-based formatting alone is more prone to occasional drift than schema-constrained generation where it's available.
Designing an overly complex schema
A schema with many optional, deeply nested, or ambiguous fields is harder for the model to fill in reliably.
Forgetting to handle malformed responses
Even with strong formatting support, an application should handle a parse failure gracefully rather than crashing.

Interview Question

What is structured output, and why would you use it over free-form text?

Structured output constrains a model's response to a defined shape — usually JSON matching a schema — instead of free-form text, so an application can reliably parse the result. You'd use it whenever the model's output feeds directly into code rather than being read by a person, like classification results or extracted data. It's implemented either through prompt instructions asking for a specific format, or more reliably through schema-constrained generation that the provider enforces directly. Either way, the application still needs to validate the result — a well-formed structure doesn't guarantee the values inside it are correct.

What an interviewer may ask next

Why is schema-constrained generation generally more reliable than prompt-based formatting instructions?
Why should you still validate structured output even when the format is enforced?
How does structured output relate to function/tool calling?

Explain It in 30 Seconds

Structured output constrains a model to return data in a defined shape — typically JSON matching a schema — instead of free-form text, so an application can parse it reliably. It's implemented through prompt instructions or, more reliably, schema-constrained generation the provider enforces directly. Either way, the application should still validate the result, since well-formed structure doesn't guarantee the values inside are actually correct.

What to learn next: Prompt Injection

AI Workspace Loading