Structured Output & JSON Mode: Get Reliable AI Responses Across Providers

Without structured output:
  User: "Extract the name and email from this text"
  AI: "The name is John Smith and the email is [email protected]"
  → You need regex/parsing to extract data 😩

With structured output:
  AI: {"name": "John Smith", "email": "[email protected]"}
  → Direct JSON.parse(), ready to use ✅

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI(
    api_key="YOUR_CRAZYROUTER_KEY",
    base_url="https://ai.crazyrouter.us/v1"
)

# Define your schema with Pydantic
class ProductReview(BaseModel):
    product_name: str
    rating: float
    pros: list[str]
    cons: list[str]
    summary: str
    recommended: bool

# Use structured output - guaranteed to match schema
response = client.beta.chat.completions.parse(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Extract a structured product review from the text."},
        {"role": "user", "content": "I bought the Sony WH-1000XM6 headphones last month. Amazing noise cancellation, super comfortable for long flights. Battery lasts 40 hours which is insane. The app is a bit clunky though, and they're pricey at $399. Sound quality is phenomenal, especially for classical music. Highly recommend if you can afford them. 9/10."}
    ],
    response_format=ProductReview
)

review = response.choices[0].message.parsed
print(f"Product: {review.product_name}")
print(f"Rating: {review.rating}/10")
print(f"Recommended: {review.recommended}")
print(f"Pros: {', '.join(review.pros)}")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Extract events from the text as JSON."},
        {"role": "user", "content": "The conference is March 15-17 in San Francisco. Keynote by Sam Altman on March 15 at 9 AM. Workshop on fine-tuning March 16 at 2 PM."}
    ],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "events",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "events": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "title": {"type": "string"},
                                "date": {"type": "string"},
                                "time": {"type": "string"},
                                "location": {"type": "string"}
                            },
                            "required": ["title", "date"],
                            "additionalProperties": False
                        }
                    }
                },
                "required": ["events"],
                "additionalProperties": False
            }
        }
    }
)

import json
events = json.loads(response.choices[0].message.content)

import anthropic

client = anthropic.Anthropic(
    api_key="YOUR_CRAZYROUTER_KEY",
    base_url="https://ai.crazyrouter.us/v1"
)

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[{
        "name": "extract_review",
        "description": "Extract a structured product review",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_name": {"type": "string"},
                "rating": {"type": "number", "minimum": 0, "maximum": 10},
                "pros": {"type": "array", "items": {"type": "string"}},
                "cons": {"type": "array", "items": {"type": "string"}},
                "summary": {"type": "string"},
                "recommended": {"type": "boolean"}
            },
            "required": ["product_name", "rating", "pros", "cons", "summary", "recommended"]
        }
    }],
    tool_choice={"type": "tool", "name": "extract_review"},
    messages=[{
        "role": "user",
        "content": "Extract a review from: Great laptop, the M4 chip is blazing fast. Battery life is incredible at 18 hours. A bit heavy at 4.7 lbs. The keyboard could be better. 8.5/10, recommended for developers."
    }]
)

# The response is guaranteed valid JSON matching the schema
review_data = response.content[0].input
print(review_data)

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemini-2.5-flash")

response = model.generate_content(
    "Extract the recipe from: Mix 2 cups flour, 1 cup sugar, 3 eggs. Bake at 350°F for 30 minutes.",
    generation_config=genai.GenerationConfig(
        response_mime_type="application/json",
        response_schema={
            "type": "object",
            "properties": {
                "recipe_name": {"type": "string"},
                "ingredients": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "item": {"type": "string"},
                            "amount": {"type": "string"}
                        }
                    }
                },
                "instructions": {"type": "array", "items": {"type": "string"}},
                "cook_time_minutes": {"type": "integer"},
                "temperature_f": {"type": "integer"}
            }
        }
    )
)

import json
recipe = json.loads(response.text)

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_CRAZYROUTER_KEY",
    base_url="https://ai.crazyrouter.us/v1"
)

# Works with ANY model through Crazyrouter
models = ["gpt-4o", "claude-sonnet-4-20250514", "gemini-2.5-flash"]

for model in models:
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "Always respond in JSON format with keys: sentiment, confidence, keywords"},
            {"role": "user", "content": "Analyze: The new AI features are amazing but the pricing is too high"}
        ],
        response_format={"type": "json_object"}
    )
    print(f"{model}: {response.choices[0].message.content}")

import json
from jsonschema import validate

schema = {
    "type": "object",
    "properties": {
        "name": {"type": "string"},
        "score": {"type": "number", "minimum": 0, "maximum": 100}
    },
    "required": ["name", "score"]
}

data = json.loads(response.choices[0].message.content)
validate(instance=data, schema=schema)  # Raises if invalid

response_format={
    "type": "json_schema",
    "json_schema": {
        "name": "classification",
        "schema": {
            "type": "object",
            "properties": {
                "category": {
                    "type": "string",
                    "enum": ["bug", "feature", "question", "documentation"]
                },
                "priority": {
                    "type": "string",
                    "enum": ["low", "medium", "high", "critical"]
                }
            }
        }
    }
}

# For streaming, collect chunks and parse at the end
full_content = ""
for chunk in client.chat.completions.create(
    model="gpt-4o",
    messages=[...],
    response_format={"type": "json_object"},
    stream=True
):
    if chunk.choices[0].delta.content:
        full_content += chunk.choices[0].delta.content

result = json.loads(full_content)