Structured outputs on Amazon Bedrock: Schema-compliant AI responses

At this time, we’re saying structured outputs on Amazon Bedrock—a functionality that basically transforms how one can receive validated JSON responses from basis fashions by way of constrained decoding for schema compliance.

This represents a paradigm shift in AI software improvement. As an alternative of validating JSON responses and writing fallback logic for after they fail, you possibly can transfer straight to constructing with the information. With structured outputs, you possibly can construct zero-validation information pipelines that belief mannequin outputs, dependable agentic methods that confidently name exterior features, and simplified software architectures with out retry logic.

On this put up, we discover the challenges of conventional JSON era and the way structured outputs solves them. We cowl the 2 core mechanisms—JSON Schema output format and strict software use—together with implementation particulars, finest practices, and sensible code examples. Whether or not you’re constructing information extraction pipelines, agentic workflows, or AI-powered APIs, you’ll discover ways to use structured outputs to create dependable, production-ready purposes. Our companion Jupyter pocket book gives hands-on examples for each characteristic lined right here.

The issue with conventional JSON era

For years, getting structured information from language fashions meant crafting detailed prompts, hoping for one of the best, and constructing elaborate error-handling methods. Even with cautious prompting, builders routinely encounter:

• Parsing failures: Invalid JSON syntax that breaks json.masses() calls
• Lacking fields: Required information factors absent from responses
• Sort mismatches: Strings the place integers are anticipated, breaking downstream processing
• Schema violations: Responses that technically parse however don’t match your information mannequin

In manufacturing methods, these failures compound. A single malformed response can cascade by way of your pipeline, requiring retries that enhance latency and prices. For agentic workflows the place fashions name instruments, invalid parameters can break operate calls totally.

Contemplate a reserving system requiring passengers: int. With out schema enforcement, the mannequin would possibly return passengers: "two" or passengers: "2"—syntactically legitimate JSON, however semantically improper to your operate signature.

What adjustments with structured outputs

Structured outputs on Amazon Bedrock isn’t incremental enchancment—it’s a elementary shift from probabilistic to deterministic output formatting. Via constrained decoding, Amazon Bedrock constrains mannequin responses to evolve to your specified JSON schema. Two complementary mechanisms can be found:

These options can be utilized independently or collectively, providing you with exact management over each what the mannequin outputs and the way it calls your features.

What structured outputs delivers:

• At all times legitimate: No extra JSON.parse() errors or parsing exceptions
• Sort secure: Discipline varieties are enforced and required fields are at all times current
• Dependable: No retries wanted for schema violations
• Manufacturing prepared: Deploy with confidence at enterprise scale

How structured outputs works

Structured outputs makes use of constrained sampling with compiled grammar artifacts. Right here’s what occurs once you make a request:

1. Schema validation: Amazon Bedrock validates your JSON schema towards the supported JSON Schema Draft 2020-12 subset
2. Grammar compilation: For brand spanking new schemas, Amazon Bedrock compiles a grammar (first request would possibly take longer)
3. Caching: Compiled grammars are cached for twenty-four hours, making subsequent requests quicker
4. Constrained era: The mannequin generates tokens that produce legitimate JSON matching your schema

Efficiency concerns:

• First request latency: Preliminary compilation would possibly add latency to new schemas
• Cached efficiency: Subsequent requests with similar schemas have minimal overhead
• Cache scope: Grammars are cached per account for twenty-four hours from first entry

Altering the JSON schema construction or a software’s enter schema invalidates the cache, however altering solely identify or description fields doesn’t.

Getting began with structured outputs

The next instance demonstrates structured outputs with the Converse API:

import boto3
import json
# Initialize the Bedrock Runtime shopper
bedrock_runtime = boto3.shopper(
    service_name="bedrock-runtime",
    region_name="us-east-1"  # Select your most popular area
)
# Outline your JSON schema
extraction_schema = {
    "sort": "object",
    "properties": {
        "identify": {"sort": "string", "description": "Buyer identify"},
        "e-mail": {"sort": "string", "description": "Buyer e-mail tackle"},
        "plan_interest": {"sort": "string", "description": "Product plan of curiosity"},
        "demo_requested": {"sort": "boolean", "description": "Whether or not a demo was requested"}
    },
    "required": ["name", "email", "plan_interest", "demo_requested"],
    "additionalProperties": False
}
# Make the request with structured outputs
response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-5-20251101-v1:0",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "text": "Extract the key information from this email: John Smith (john@example.com) is interested in our Enterprise plan and wants to schedule a demo for next Tuesday at 2pm."
                }
            ]
        }
    ],
    inferenceConfig={
        "maxTokens": 1024
    },
    outputConfig={
        "textFormat": {
            "sort": "json_schema",
            "construction": {
                "jsonSchema": {
                    "schema": json.dumps(extraction_schema),
                    "identify": "lead_extraction",
                    "description": "Extract lead info from buyer emails"
                }
            }
        }
    }
)
# Parse the schema-compliant JSON response
consequence = json.masses(response["output"]["message"]["content"][0]["text"])
print(json.dumps(consequence, indent=2))

Output:

{
  "identify": "John Smith",
  "e-mail": "john@instance.com",
  "plan_interest": "Enterprise",
  "demo_requested": true
}

The response conforms to your schema—no further validation required.

Necessities and finest practices

To make use of structured outputs successfully, comply with these tips:

• Set additionalProperties: false on all objects. That is required for structured outputs to work. With out it, your schema gained’t be accepted.

{
  "sort": "object",
  "properties": {
    "identify": {"sort": "string"}
  },
  "required": ["name"],
  "additionalProperties": false
}

• Use descriptive subject names and descriptions. Fashions use property names and descriptions to grasp what information to extract. Clear names like customer_email outperform generic names like field1.
• Use enum for constrained values. When a subject has a restricted set of legitimate values, use enum to constrain choices. This improves accuracy and produces legitimate values.
• Begin primary, then add complexity. Start with the minimal required fields and add complexity incrementally. Primary schemas compile quicker and are simpler to keep up.
• Reuse schemas to profit from caching. Construction your software to reuse schemas throughout requests. The 24-hour grammar cache considerably improves efficiency for repeated queries.
• Examine stopReason in each response. Two eventualities can produce non-conforming responses: refusals (when the mannequin declines for security causes) and token limits (when max_tokens is reached earlier than finishing). Deal with each instances in your code.
• Take a look at with real looking information earlier than deployment. Validate your schemas towards production-representative inputs. Edge instances in actual information typically reveal schema design points.

Supported JSON Schema options:

• All primary varieties: object, array, string, integer, quantity, boolean, null
• enum (strings, numbers, bools, or nulls solely)
• const, anyOf, allOf (with limitations)
• $ref, $def, and definitions (inner references solely)
• String codecs: date-time, time, date, length, e-mail, hostname, uri, ipv4, ipv6, uuid
• Array minItems (solely values 0 and 1)

Not supported:

• Recursive schemas
• Exterior $ref references
• Numerical constraints (minimal, most, multipleOf)
• String constraints (minLength, maxLength)
• additionalProperties set to something aside from false

Strict software use for agentic workflows

When constructing purposes the place fashions name instruments, set strict: true in your software definition to constrain software parameters to match your enter schema precisely:

import boto3
import json
bedrock_runtime = boto3.shopper('bedrock-runtime', region_name="us-east-1")
response = bedrock_runtime.converse(
    modelId="us.anthropic.claude-opus-4-5-20251101-v1:0",
    messages=[
        {
            "role": "user",
            "content": [{"text": "What's the weather like in San Francisco?"}]
        }
    ],
    inferenceConfig={"maxTokens": 1024},
    toolConfig={
        "instruments": [
            {
                "toolSpec": {
                    "name": "get_weather",
                    "description": "Get the current weather for a specified location",
                    "strict": True,  # Enable strict mode
                    "inputSchema": {
                        "json": {
                            "type": "object",
                            "properties": {
                                "location": {
                                    "type": "string",
                                    "description": "The city and state, e.g., San Francisco, CA"
                                },
                                "unit": {
                                    "type": "string",
                                    "enum": ["celsius", "fahrenheit"],
                                    "description": "Temperature unit"
                                }
                            },
                            "required": ["location", "unit"],
                            "additionalProperties": False
                        }
                    }
                }
            }
        ]
    }
)
# Device inputs conform to the schema
for content_block in response["output"]["message"]["content"]:
    if "toolUse" in content_block:
        tool_input = content_block["toolUse"]["input"]
        print(f"Device: {content_block['toolUse']['name']}")
        print(f"Enter: {json.dumps(tool_input, indent=2)}")

With strict: true, structured outputs constrains the output in order that:

• The location subject is at all times a string
• The unit subject is at all times both celsius or fahrenheit
• No sudden fields seem within the enter

Sensible purposes throughout industries

The pocket book demonstrates use instances that span industries:

• Monetary providers: Extract structured information from earnings experiences, mortgage purposes, and compliance paperwork. With structured outputs, each required subject is current and accurately typed for downstream processing.
• Healthcare: Parse medical notes into structured, schema-compliant data. Extract affected person info, diagnoses, and remedy plans into validated JSON for EHR integration.
• Ecommerce: Construct dependable product catalog enrichment pipelines. Extract specs, classes, and attributes from product descriptions with constant, dependable outcomes.
• Authorized: Analyze contracts and extract key phrases, events, dates, and obligations into structured codecs appropriate for contract administration methods.
• Customer support: Construct clever ticket routing and response methods the place extracted intents, sentiments, and entities match your software’s information mannequin.

Selecting the best method

Our testing revealed clear patterns for when to make use of every characteristic:

Use JSON Schema output format when:

• You want the mannequin’s response in a particular construction
• Constructing information extraction pipelines
• Producing API-ready responses
• Creating structured experiences or summaries

Use strict software use when:

• Constructing agentic methods that decision exterior features
• Implementing multi-step workflows with software chains
• Requiring validated parameter varieties for operate calls
• Connecting AI to databases, APIs, or exterior providers

Use each collectively when:

• Constructing complicated brokers that want validated software calls and structured closing responses
• Creating methods the place intermediate software outcomes feed into structured outputs
• Implementing enterprise workflows requiring end-to-end schema compliance

API comparability: Converse in comparison with InvokeModel

Each the Converse API and InvokeModel API help structured outputs, with barely completely different parameter codecs:

Be aware: The InvokeModel API makes use of completely different request subject names relying on the mannequin sort. For Anthropic Claude fashions, use output_config.format for JSON schema outputs. For open-weight fashions, use response_format as an alternative.

Select the Converse API for multi-turn conversations and the InvokeModel API once you want direct mannequin entry with provider-specific request codecs.

Supported fashions and availability

Structured outputs is usually out there in all business AWS Areas for choose Amazon Bedrock mannequin suppliers:

• Anthropic
• DeepSeek
• Google
• MiniMax
• Mistral AI
• Moonshot AI
• NVIDIA
• OpenAI
• Qwen

The characteristic works seamlessly with:

• Cross-Area inference: Use structured outputs throughout AWS Areas with out further setup
• Batch inference: Course of giant volumes with schema-compliant outputs
• Streaming: Stream structured responses with ConverseStream or InvokeModelWithResponseStream

Conclusion

On this put up, you found how structured outputs on Amazon Bedrock scale back the uncertainty of AI-generated JSON by way of validated, schema-compliant responses. Through the use of JSON Schema output format and strict software use, you possibly can construct dependable information extraction pipelines, sturdy agentic workflows, and production-ready AI purposes—with out customized parsing or validation logic.Whether or not you’re extracting information from paperwork, constructing clever automation, or creating AI-powered APIs, structured outputs ship the reliability your purposes demand.

Structured outputs is now typically out there on Amazon Bedrock. To make use of structured outputs with the Converse APIs, replace to the newest AWS SDK. To be taught extra, see the Amazon Bedrock documentation and discover our pattern pocket book.

What workflows may validated, schema-compliant JSON unlock in your group? The pocket book gives every little thing it’s essential to discover out.

In regards to the authors