Structured Output

Structured output lets you define a JSON schema for the model’s response, ensuring you get consistently typed data back. The OpenAI format uses the standard response_format parameter. The Anthropic Messages format has no response_format; instead you achieve the same result with forced tool use — define a tool whose input_schema is your target schema, require it via tool_choice, and read the typed tool_use block from the response.

JSON Schema

Pass a JSON schema via response_format (OpenAI) or a forced tool (Anthropic) to constrain the model’s output:

from openai import OpenAI
import json

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.subconscious.dev/v1",
)

response = client.chat.completions.create(
    model="subconscious/tim-qwen3.6-27b",
    messages=[{"role": "user", "content": "Extract the key facts from: 'Tesla reported $25.5B in Q3 2024 revenue, up 8% year-over-year.'"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "financial_extract",
            "schema": {
                "type": "object",
                "properties": {
                    "company": {"type": "string"},
                    "revenue": {"type": "string"},
                    "period": {"type": "string"},
                    "growth": {"type": "string"},
                },
                "required": ["company", "revenue", "period", "growth"],
            },
        },
    },
)

result = json.loads(response.choices[0].message.content)
print(result)
# {"company": "Tesla", "revenue": "$25.5B", "period": "Q3 2024", "growth": "8% YoY"}

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "your-api-key",
  baseURL: "https://api.subconscious.dev/v1",
});

const response = await client.chat.completions.create({
  model: "subconscious/tim-qwen3.6-27b",
  messages: [
    {
      role: "user",
      content:
        "Extract the key facts from: 'Tesla reported $25.5B in Q3 2024 revenue, up 8% year-over-year.'",
    },
  ],
  response_format: {
    type: "json_schema",
    json_schema: {
      name: "financial_extract",
      schema: {
        type: "object",
        properties: {
          company: { type: "string" },
          revenue: { type: "string" },
          period: { type: "string" },
          growth: { type: "string" },
        },
        required: ["company", "revenue", "period", "growth"],
      },
    },
  },
});

const result = JSON.parse(response.choices[0].message.content!);
console.log(result);

from anthropic import Anthropic

client = Anthropic(
    auth_token="your-api-key",
    base_url="https://api.subconscious.dev",
)

schema = {
    "type": "object",
    "properties": {
        "company": {"type": "string"},
        "revenue": {"type": "string"},
        "period": {"type": "string"},
        "growth": {"type": "string"},
    },
    "required": ["company", "revenue", "period", "growth"],
}

message = client.messages.create(
    model="subconscious/tim-qwen3.6-27b",
    max_tokens=1024,
    tools=[{
        "name": "financial_extract",
        "description": "Record the extracted financial facts.",
        "input_schema": schema,
    }],
    tool_choice={"type": "tool", "name": "financial_extract"},
    messages=[{"role": "user", "content": "Extract the key facts from: 'Tesla reported $25.5B in Q3 2024 revenue, up 8% year-over-year.'"}],
)

result = next(b.input for b in message.content if b.type == "tool_use")
print(result)
# {"company": "Tesla", "revenue": "$25.5B", "period": "Q3 2024", "growth": "8% YoY"}

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  authToken: "your-api-key",
  baseURL: "https://api.subconscious.dev",
});

const message = await client.messages.create({
  model: "subconscious/tim-qwen3.6-27b",
  max_tokens: 1024,
  tools: [
    {
      name: "financial_extract",
      description: "Record the extracted financial facts.",
      input_schema: {
        type: "object",
        properties: {
          company: { type: "string" },
          revenue: { type: "string" },
          period: { type: "string" },
          growth: { type: "string" },
        },
        required: ["company", "revenue", "period", "growth"],
      },
    },
  ],
  tool_choice: { type: "tool", name: "financial_extract" },
  messages: [
    {
      role: "user",
      content:
        "Extract the key facts from: 'Tesla reported $25.5B in Q3 2024 revenue, up 8% year-over-year.'",
    },
  ],
});

const block = message.content.find((b) => b.type === "tool_use");
console.log(block?.input);

With Pydantic (Python)

Use Pydantic models to define your schema and parse the response. The same model_json_schema() output works as the OpenAI json_schema or as an Anthropic tool’s input_schema:

from openai import OpenAI
from pydantic import BaseModel

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.subconscious.dev/v1",
)

class SentimentAnalysis(BaseModel):
    sentiment: str
    confidence: float
    keywords: list[str]

response = client.chat.completions.create(
    model="subconscious/tim-qwen3.6-27b",
    messages=[{"role": "user", "content": "Analyze: 'The new update is fantastic, everything runs so smoothly now!'"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "sentiment_analysis",
            "schema": SentimentAnalysis.model_json_schema(),
        },
    },
)

result = SentimentAnalysis.model_validate_json(response.choices[0].message.content)
print(result.sentiment)    # "positive"
print(result.confidence)   # 0.95
print(result.keywords)     # ["fantastic", "smoothly"]

import json
from anthropic import Anthropic
from pydantic import BaseModel

client = Anthropic(
    auth_token="your-api-key",
    base_url="https://api.subconscious.dev",
)

class SentimentAnalysis(BaseModel):
    sentiment: str
    confidence: float
    keywords: list[str]

message = client.messages.create(
    model="subconscious/tim-qwen3.6-27b",
    max_tokens=1024,
    tools=[{
        "name": "sentiment_analysis",
        "description": "Record the sentiment analysis result.",
        "input_schema": SentimentAnalysis.model_json_schema(),
    }],
    tool_choice={"type": "tool", "name": "sentiment_analysis"},
    messages=[{"role": "user", "content": "Analyze: 'The new update is fantastic, everything runs so smoothly now!'"}],
)

raw = next(b.input for b in message.content if b.type == "tool_use")
result = SentimentAnalysis.model_validate(raw)
print(result.sentiment)    # "positive"
print(result.confidence)   # 0.95
print(result.keywords)     # ["fantastic", "smoothly"]

With Zod (TypeScript)

Use Zod schemas with zodResponseFormat (OpenAI), or convert the Zod schema to JSON Schema and use it as an Anthropic tool’s input_schema:

import OpenAI from "openai";
import { zodResponseFormat } from "openai/helpers/zod";
import { z } from "zod";

const client = new OpenAI({
  apiKey: "your-api-key",
  baseURL: "https://api.subconscious.dev/v1",
});

const SentimentAnalysis = z.object({
  sentiment: z.enum(["positive", "negative", "neutral"]),
  confidence: z.number(),
  keywords: z.array(z.string()),
});

const response = await client.chat.completions.create({
  model: "subconscious/tim-qwen3.6-27b",
  messages: [
    {
      role: "user",
      content:
        "Analyze: 'The new update is fantastic, everything runs so smoothly now!'",
    },
  ],
  response_format: zodResponseFormat(SentimentAnalysis, "sentiment_analysis"),
});

const result = SentimentAnalysis.parse(
  JSON.parse(response.choices[0].message.content!)
);
console.log(result.sentiment); // "positive"

import Anthropic from "@anthropic-ai/sdk";
import { z } from "zod";
import { zodToJsonSchema } from "zod-to-json-schema";

const client = new Anthropic({
  authToken: "your-api-key",
  baseURL: "https://api.subconscious.dev",
});

const SentimentAnalysis = z.object({
  sentiment: z.enum(["positive", "negative", "neutral"]),
  confidence: z.number(),
  keywords: z.array(z.string()),
});

const message = await client.messages.create({
  model: "subconscious/tim-qwen3.6-27b",
  max_tokens: 1024,
  tools: [
    {
      name: "sentiment_analysis",
      description: "Record the sentiment analysis result.",
      input_schema: zodToJsonSchema(SentimentAnalysis) as Anthropic.Tool.InputSchema,
    },
  ],
  tool_choice: { type: "tool", name: "sentiment_analysis" },
  messages: [
    {
      role: "user",
      content:
        "Analyze: 'The new update is fantastic, everything runs so smoothly now!'",
    },
  ],
});

const block = message.content.find((b) => b.type === "tool_use");
const result = SentimentAnalysis.parse(block?.input);
console.log(result.sentiment); // "positive"

JSON Mode

JSON mode is specific to the OpenAI format. For simpler cases where you just need valid JSON without a specific schema, use JSON mode. (The Anthropic Messages format has no JSON mode — use the forced tool-use pattern shown above when you need structured JSON.)

Python

response = client.chat.completions.create(
    model="subconscious/tim-qwen3.6-27b",
    messages=[
        {"role": "system", "content": "Respond only in JSON."},
        {"role": "user", "content": "List three programming languages and their main use cases."},
    ],
    response_format={"type": "json_object"},
)

When using JSON mode without a schema, include “respond in JSON” or similar instructions in your prompt. The model needs to know you expect JSON output.

Get started

Features

Ways to use

Resources

JSON Schema

With Pydantic (Python)

With Zod (TypeScript)

JSON Mode

​JSON Schema

​With Pydantic (Python)

​With Zod (TypeScript)

​JSON Mode

JSON Schema

With Pydantic (Python)

With Zod (TypeScript)

JSON Mode