结构化输出

Java 会在类的元数据中保留字段的泛型类型信息，但在其他作用域中会发生泛型类型擦除。虽然可以从类型为 List<Book> 的 BookList.books 字段派生 JSON schema，但无法从相同类型的局部变量派生有效的 JSON schema。

如果在将 JSON 响应转换为 Java 类实例时发生错误，错误消息会包含 JSON 响应以帮助诊断。如果您的 JSON 响应可能包含敏感信息，请避免直接记录它，或确保从错误消息中删除所有敏感细节。

结构化输出支持 JSON Schema 语言的子集。SDK 会从类自动生成符合该子集的 schema。outputConfig(Class<T>) 方法会对从指定类派生的 schema 执行验证检查。

要点：

• 本地验证无需向远程 AI 模型发送请求即可进行。
• 远程验证也会在 AI 模型收到 JSON schema 时执行。
• 版本兼容性：如果 SDK 版本过旧，本地验证可能会拒绝远程验证接受的 schema。
• 禁用本地验证：如果遇到兼容性问题，请传递 JsonSchemaLocalValidation.NO：

import com.anthropic.core.JsonSchemaLocalValidation;
// ...

static class BookList {
    public List<String> books;
}

void main() {
    StructuredMessageCreateParams<BookList> createParams = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(2048)
        .outputConfig(BookList.class, JsonSchemaLocalValidation.NO)
        .addUserMessage("List some famous late twentieth century novels.")
        .build();
}

结构化输出也支持“streaming”（流式传输）。由于响应以流事件的形式到达，您需要先累积完整响应，然后再反序列化 JSON。

使用 MessageAccumulator 从流中收集 JSON 字符串。累积完成后，调用 MessageAccumulator.message(Class<T>) 将累积的 Message 转换为 StructuredMessage，它会自动将 JSON 反序列化为您的 Java 类。

当 SDK 从您的 Java 类派生 JSON schema 时，默认会包含由 public 字段或 public getter 方法表示的所有属性，并排除非 public 的字段和 getter 方法。

您可以使用注解控制可见性：

• @JsonIgnore 会排除 public 字段或 getter 方法。
• @JsonProperty 会包含非 public 字段或 getter 方法。

如果您定义了带有 public getter 方法的 private 字段，SDK 会从 getter 派生属性名（例如，private 字段 myValue 配合 public 方法 getMyValue() 会生成 "myValue" 属性）。要使用非常规的 getter 名称，请使用 @JsonProperty 注解该方法。

每个类必须为 JSON schema 定义至少一个属性。如果没有字段或 getter 方法能生成 schema 属性，就会发生验证错误，例如：

• 类中没有字段或 getter 方法
• 所有 public 成员都使用了 @JsonIgnore 注解
• 所有非 public 成员都缺少 @JsonProperty 注解
• 某个字段使用 Map 类型，这会生成空的 "properties" 字段

您的 Java 类可以在定义 JSON schema 时使用组合和继承来共享结构。每种模式对输出结构的影响不同。

组合会生成嵌套的 JSON 输出。从组合了 A 和 B 的类 Composed 派生 schema：

static class A {
    public String a;
}

static class B {
    public String b;
}

static class Composed {
    public A composedA;
    public B composedB;
}

JSON 输出具有如下嵌套结构：

Output

{
  "composedA": { "a": "hello" },
  "composedB": { "b": "world" }
}

继承会生成扁平的 JSON 输出。从继承 Base 的类 Derived 派生 schema：

static class Base {
    public String a;
}

static class Derived extends Base {
    public String b;
}

JSON 输出具有如下扁平结构：

Output

{
  "a": "hello",
  "b": "world"
}

您可以使用 Jackson Databind 注解来丰富从 Java 类派生的 JSON schema：

import com.fasterxml.jackson.annotation.JsonClassDescription;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonPropertyDescription;

static class Person {

    @JsonPropertyDescription("The first name and surname of the person")
    public String name;

    public int birthYear;

    @JsonPropertyDescription("The year the person died, or 'present' if the person is living.")
    public String deathYear;
}

@JsonClassDescription("The details of one published book")
static class Book {

    public String title;
    public Person author;

    @JsonPropertyDescription("The year in which the book was first published.")
    public int publicationYear;

    @JsonIgnore
    public String genre;
}

static class BookList {
    public List<Book> books;
}

注解汇总：

• @JsonClassDescription：为类添加描述
• @JsonPropertyDescription：为字段或 getter 方法添加描述
• @JsonIgnore：从 schema 中排除 public 字段或 getter
• @JsonProperty：在 schema 中包含非 public 字段或 getter

如果您使用 @JsonProperty(required = false)，SDK 会忽略 false 值。从类派生的 schema 始终将所有属性标记为必填。

您还可以使用 Swagger Core（OpenAPI 3）的 @Schema 和 @ArraySchema 注解来添加特定于类型的约束：

import io.swagger.v3.oas.annotations.media.ArraySchema;
import io.swagger.v3.oas.annotations.media.Schema;

static class Article {

    @ArraySchema(minItems = 1)
    public List<String> authors;

    public String title;

    @Schema(format = "date")
    public String publicationDate;

    public int pageCount;
}

本地验证会检查您是否使用了不受支持的约束关键字，但不会在本地验证约束值。例如，不受支持的 "format" 值可能会通过本地验证，但会导致远程错误。

如果您同时使用 Jackson 和 Swagger 注解设置同一个 schema 字段，则 Jackson 注解优先。

SDK 将原生 PHP 8 属性类型映射到 JSON Schema：

对于 array 属性，仅当元素类型是嵌套的 StructuredOutputModel（通过 #[Constrained(itemClass: MyModel::class)] 或 /** @var MyModel[] */ 文档块声明）时，SDK 才会添加 items schema。标量数组（string[]、int[]）会生成无约束的 {"type":"array"}。

所有不可为空的属性都会成为必填字段。

使用 #[Constrained] 属性添加约束：

use Anthropic\Lib\Attributes\Constrained;
use Anthropic\Lib\Concerns\StructuredOutputModelTrait;
use Anthropic\Lib\Contracts\StructuredOutputModel;

class Address implements StructuredOutputModel { use StructuredOutputModelTrait; public string $street; }

class Profile implements StructuredOutputModel
{
    use StructuredOutputModelTrait;

    #[Constrained(description: 'Age in years', minimum: 0, maximum: 150)]
    public int $age;

    #[Constrained(format: 'email')]
    public string $email;

    #[Constrained(itemClass: Address::class, minItems: 1)]
    public array $addresses;
}

由 API 强制执行的约束（在 schema 中发送）：description、format、const、itemClass、minItems（仅限 0 或 1）。

由 SDK 验证的约束（从发送的 schema 中移除，追加到描述中，并针对响应进行验证）：minimum、maximum、multipleOf、minLength、maxLength。

Ruby SDK 支持额外的模型定义功能，以生成更丰富的 schema：

• doc: 关键字：为字段添加描述，使 schema 输出信息更丰富
• Anthropic::ArrayOf[T]：类型化数组。将数组级约束（min_items:、max_items:）作为关键字传递给 required/optional，而不是传递给 ArrayOf 本身
• Anthropic::EnumOf[:a, :b]：具有受限值的枚举字段
• Anthropic::UnionOf[T1, T2]：映射到 anyOf 的联合类型

class FamousNumber < Anthropic::BaseModel
  required :value, Float
  optional :reason, String, doc: "why is this number mathematically significant?"
end

class Output < Anthropic::BaseModel
  required :numbers, Anthropic::ArrayOf[FamousNumber], min_items: 3, max_items: 5
end

message = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  messages: [{role: "user", content: "give me some famous numbers"}],
  output_config: {format: Output}
)

message.parsed_output
# => #<Output numbers=[#<FamousNumber value=3.14159... reason="Pi is...">...]>

从非结构化文本中提取结构化数据：

cURL

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 4096,
    "messages": [
      {
        "role": "user",
        "content": "Extract invoice data from: Invoice #12345, Date: 2024-01-15, Total: $500.00"
      }
    ],
    "output_config": {
      "format": {
        "type": "json_schema",
        "schema": {
          "type": "object",
          "properties": {
            "invoice_number": {"type": "string"},
            "date": {"type": "string"},
            "total_amount": {"type": "number"},
            "line_items": {
              "type": "array",
              "items": {"type": "object", "additionalProperties": false}
            },
            "customer_name": {"type": "string"}
          },
          "required": ["invoice_number", "date", "total_amount", "line_items", "customer_name"],
          "additionalProperties": false
        }
      }
    }
  }'

CLI

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 4096
messages:
  - role: user
    content: "Extract invoice data from: Invoice #12345, Date: 2024-01-15, Total: $500.00"
output_config:
  format:
    type: json_schema
    schema:
      type: object
      properties:
        invoice_number: {type: string}
        date: {type: string}
        total_amount: {type: number}
        line_items:
          type: array
          items: {type: object, additionalProperties: false}
        customer_name: {type: string}
      required: [invoice_number, date, total_amount, line_items, customer_name]
      additionalProperties: false
YAML

Python

from pydantic import BaseModel


class Invoice(BaseModel):
    invoice_number: str
    date: str
    total_amount: float
    line_items: list[dict]
    customer_name: str


client = anthropic.Anthropic()
invoice_text = "Invoice #12345, Date: 2024-01-15, Total: $500.00"

response = client.messages.parse(
    model="claude-opus-5-5",
    max_tokens=4096,
    output_format=Invoice,
    messages=[
        {"role": "user", "content": f"Extract invoice data from: {invoice_text}"}
    ],
)

print(response.parsed_output)

TypeScript

import { z } from "zod";
import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";

const client = new Anthropic();

const InvoiceSchema = z.object({
  invoice_number: z.string(),
  date: z.string(),
  total_amount: z.number(),
  line_items: z.array(z.record(z.string(), z.any())),
  customer_name: z.string()
});

const invoiceText = "Invoice #12345, Date: 2024-01-15, Total: $500.00";
const response = await client.messages.parse({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  output_config: { format: zodOutputFormat(InvoiceSchema) },
  messages: [{ role: "user", content: `Extract invoice data from: ${invoiceText}` }]
});
console.log(response.parsed_output);

C#

AnthropicClient client = new();

string invoiceText = "Invoice #12345, Date: 2024-01-15, Total: $500.00";

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    OutputConfig = new OutputConfig
    {
        Format = new JsonOutputFormat
        {
            Schema = new Dictionary<string, JsonElement>
            {
                ["type"] = JsonSerializer.SerializeToElement("object"),
                ["properties"] = JsonSerializer.SerializeToElement(new
                {
                    invoice_number = new { type = "string" },
                    date = new { type = "string" },
                    total_amount = new { type = "number" },
                    line_items = new
                    {
                        type = "array",
                        items = new
                        {
                            type = "object",
                            additionalProperties = false,
                        },
                    },
                    customer_name = new { type = "string" },
                }),
                ["required"] = JsonSerializer.SerializeToElement(new[] { "invoice_number", "date", "total_amount", "line_items", "customer_name" }),
                ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
            },
        },
    },
    Messages = [new UserMessageParam { Content = $"Extract invoice data from: {invoiceText}" }]
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

Go

client := anthropic.NewClient()

invoiceText := "Invoice #12345, Date: 2024-01-15, Total: $500.00"

schema := map[string]any{
	"type":                 "object",
	"additionalProperties": false,
	"properties": map[string]any{
		"invoice_number": map[string]any{"type": "string"},
		"date":           map[string]any{"type": "string"},
		"total_amount":   map[string]any{"type": "number"},
		"line_items": map[string]any{
			"type": "array",
			"items": map[string]any{
				"type":                 "object",
				"additionalProperties": false,
				"properties": map[string]any{
					"description": map[string]any{"type": "string"},
					"quantity":    map[string]any{"type": "number"},
					"unit_price":  map[string]any{"type": "number"},
				},
				"required": []string{"description", "quantity", "unit_price"},
			},
		},
		"customer_name": map[string]any{"type": "string"},
	},
	"required": []string{"invoice_number", "date", "total_amount", "line_items", "customer_name"},
}

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	OutputConfig: anthropic.OutputConfigParam{
		Format: anthropic.JSONOutputFormatParam{
			Schema: schema,
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock(fmt.Sprintf("Extract invoice data from: %s", invoiceText))),
	},
})
if err != nil {
	log.Fatal(err)
}
for _, block := range response.Content {
	switch variant := block.AsAny().(type) {
	case anthropic.TextBlock:
		fmt.Println(variant.Text)
	}
}

Java

import com.fasterxml.jackson.annotation.JsonProperty;

static class LineItem {
    @JsonProperty("description")
    public String description;

    @JsonProperty("quantity")
    public int quantity;

    @JsonProperty("unit_price")
    public double unitPrice;
}

static class Invoice {
    @JsonProperty("invoice_number")
    public String invoiceNumber;

    @JsonProperty("date")
    public String date;

    @JsonProperty("total_amount")
    public double totalAmount;

    @JsonProperty("line_items")
    public List<LineItem> lineItems;

    @JsonProperty("customer_name")
    public String customerName;
}

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    String invoiceText = "Invoice #12345, Date: 2024-01-15, Total: $500.00";

    StructuredMessageCreateParams<Invoice> params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(4096L)
        .outputConfig(Invoice.class)
        .addUserMessage("Extract invoice data from: " + invoiceText)
        .build();

    StructuredMessage<Invoice> response = client.messages().create(params);
    Invoice invoice = response.content().stream()
        .flatMap(block -> block.text().stream())
        .findFirst().orElseThrow().text();
    IO.println(invoice.invoiceNumber + ": $" + invoice.totalAmount);
}

PHP

use Anthropic\Lib\Concerns\StructuredOutputModelTrait;
use Anthropic\Lib\Contracts\StructuredOutputModel;

$client = new Client();

class Invoice implements StructuredOutputModel
{
    use StructuredOutputModelTrait;

    public string $invoice_number;
    public string $date;
    public float $total_amount;
    public array $line_items;
    public string $customer_name;
}

$invoiceText = "Invoice #12345, Date: 2024-01-15, Total: $500.00";

$message = $client->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => "Extract invoice data from: $invoiceText"]
    ],
    model: 'claude-opus-5-5',
    outputConfig: ['format' => Invoice::class],
);

$invoice = $message->parsedOutput();
if ($invoice instanceof Invoice) {
    echo "Invoice {$invoice->invoice_number}: \${$invoice->total_amount}\n";
}

Ruby

client = Anthropic::Client.new

class LineItem < Anthropic::BaseModel
  required :description, String
  required :amount, Float
end

class Invoice < Anthropic::BaseModel
  required :invoice_number, String
  required :date, String
  required :total_amount, Float
  required :line_items, Anthropic::ArrayOf[LineItem]
  required :customer_name, String
end

invoice_text = "Invoice #12345, Date: 2024-01-15, Total: $500.00"

message = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 4096,
  output_config: {format: Invoice},
  messages: [
    {role: "user", content: "Extract invoice data from: #{invoice_text}"}
  ]
)

invoice = message.parsed_output
puts "Invoice #{invoice.invoice_number}: $#{invoice.total_amount}"

使用结构化类别对内容进行分类：

cURL

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Classify this feedback: Great product, fast shipping!"
      }
    ],
    "output_config": {
      "format": {
        "type": "json_schema",
        "schema": {
          "type": "object",
          "properties": {
            "category": {"type": "string"},
            "confidence": {"type": "number"},
            "tags": {"type": "array", "items": {"type": "string"}},
            "sentiment": {"type": "string"}
          },
          "required": ["category", "confidence", "tags", "sentiment"],
          "additionalProperties": false
        }
      }
    }
  }'

CLI

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
messages:
  - role: user
    content: "Classify this feedback: Great product, fast shipping!"
output_config:
  format:
    type: json_schema
    schema:
      type: object
      properties:
        category:
          type: string
        confidence:
          type: number
        tags:
          type: array
          items:
            type: string
        sentiment:
          type: string
      required:
        - category
        - confidence
        - tags
        - sentiment
      additionalProperties: false
YAML

Python

from pydantic import BaseModel

client = Anthropic()


class Classification(BaseModel):
    category: str
    confidence: float
    tags: list[str]
    sentiment: str


feedback_text = "Great product, but the delivery was slow."
response = client.messages.parse(
    model="claude-opus-5-5",
    max_tokens=1024,
    output_format=Classification,
    messages=[{"role": "user", "content": f"Classify this feedback: {feedback_text}"}],
)

print(response.parsed_output)

TypeScript

import { z } from "zod";
import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";

const client = new Anthropic();

const ClassificationSchema = z.object({
  category: z.string(),
  confidence: z.number(),
  tags: z.array(z.string()),
  sentiment: z.string()
});

const feedbackText = "Great product, but the delivery was slow.";
const response = await client.messages.parse({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  output_config: { format: zodOutputFormat(ClassificationSchema) },
  messages: [{ role: "user", content: `Classify this feedback: ${feedbackText}` }]
});

console.log(response.parsed_output);

C#

string feedbackText = "Great product, fast shipping!";

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Messages = [new UserMessageParam { Content = $"Classify this feedback: {feedbackText}" }],
    OutputConfig = new OutputConfig
    {
        Format = new JsonOutputFormat
        {
            Schema = new Dictionary<string, JsonElement>
            {
                ["type"] = JsonSerializer.SerializeToElement("object"),
                ["properties"] = JsonSerializer.SerializeToElement(new
                {
                    category = new { type = "string" },
                    confidence = new { type = "number" },
                    tags = new { type = "array", items = new { type = "string" } },
                    sentiment = new { type = "string" },
                }),
                ["required"] = JsonSerializer.SerializeToElement(new[] { "category", "confidence", "tags", "sentiment" }),
                ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
            },
        },
    },
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

Go

feedbackText := "Great product, fast shipping!"

schema := map[string]any{
	"type": "object",
	"properties": map[string]any{
		"category":   map[string]any{"type": "string"},
		"confidence": map[string]any{"type": "number"},
		"tags":       map[string]any{"type": "array", "items": map[string]any{"type": "string"}},
		"sentiment":  map[string]any{"type": "string"},
	},
	"required":             []string{"category", "confidence", "tags", "sentiment"},
	"additionalProperties": false,
}

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	OutputConfig: anthropic.OutputConfigParam{
		Format: anthropic.JSONOutputFormatParam{
			Schema: schema,
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock(fmt.Sprintf("Classify this feedback: %s", feedbackText))),
	},
})
if err != nil {
	log.Fatal(err)
}
for _, block := range response.Content {
	switch variant := block.AsAny().(type) {
	case anthropic.TextBlock:
		var result map[string]any
		json.Unmarshal([]byte(variant.Text), &result)
		fmt.Println(result)
	}
}

Java

import com.fasterxml.jackson.annotation.JsonProperty;

static class Classification {
    @JsonProperty("category")
    public String category;

    @JsonProperty("confidence")
    public double confidence;

    @JsonProperty("tags")
    public List<String> tags;

    @JsonProperty("sentiment")
    public String sentiment;
}

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    String feedbackText = "Great product, fast shipping!";

    StructuredMessageCreateParams<Classification> params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024L)
        .outputConfig(Classification.class)
        .addUserMessage("Classify this feedback: " + feedbackText)
        .build();

    StructuredMessage<Classification> response = client.messages().create(params);
    Classification result = response.content().stream()
        .flatMap(block -> block.text().stream())
        .findFirst().orElseThrow().text();
    IO.println(result.category + " (" + result.confidence + ")");
}

PHP

use Anthropic\Lib\Concerns\StructuredOutputModelTrait;
use Anthropic\Lib\Contracts\StructuredOutputModel;

$client = new Client();

class Classification implements StructuredOutputModel
{
    use StructuredOutputModelTrait;

    public string $category;
    public float $confidence;
    public array $tags;
    public string $sentiment;
}

$feedbackText = 'Great product, fast shipping!';

$message = $client->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => "Classify this feedback: {$feedbackText}"]
    ],
    model: 'claude-opus-5-5',
    outputConfig: ['format' => Classification::class],
);

$result = $message->parsedOutput();
if ($result instanceof Classification) {
    echo "{$result->category} ({$result->confidence}): {$result->sentiment}\n";
}

Ruby

client = Anthropic::Client.new

class Classification < Anthropic::BaseModel
  required :category, String
  required :confidence, Float
  required :tags, Anthropic::ArrayOf[String]
  required :sentiment, String
end

feedback_text = "Great product, fast shipping!"

message = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  output_config: {format: Classification},
  messages: [
    {role: "user", content: "Classify this feedback: #{feedback_text}"}
  ]
)
puts message.parsed_output

生成可直接用于 API 的响应：

cURL

curl https://api.anthropic.com/v1/messages \
  -H "content-type: application/json" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -d '{
    "model": "claude-opus-5-5",
    "max_tokens": 1024,
    "messages": [
      {
        "role": "user",
        "content": "Process this request: ..."
      }
    ],
    "output_config": {
      "format": {
        "type": "json_schema",
        "schema": {
          "type": "object",
          "properties": {
            "status": {"type": "string"},
            "data": {"type": "object", "additionalProperties": false},
            "errors": {
              "type": "array",
              "items": {"type": "object", "additionalProperties": false}
            },
            "metadata": {"type": "object", "additionalProperties": false}
          },
          "required": ["status", "data", "metadata"],
          "additionalProperties": false
        }
      }
    }
  }'

CLI

ant messages create <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
output_config:
  format:
    type: json_schema
    schema:
      type: object
      properties:
        status:
          type: string
        data:
          type: object
          additionalProperties: false
        errors:
          type: array
          items:
            type: object
            additionalProperties: false
        metadata:
          type: object
          additionalProperties: false
      required:
        - status
        - data
        - metadata
      additionalProperties: false
messages:
  - role: user
    content: "Process this request: ..."
YAML

Python

from pydantic import BaseModel

client = Anthropic()


class APIResponse(BaseModel):
    status: str
    data: dict
    errors: list[dict] | None
    metadata: dict


response = client.messages.parse(
    model="claude-opus-5-5",
    max_tokens=1024,
    output_format=APIResponse,
    messages=[{"role": "user", "content": "Process this request: ..."}],
)

print(response.parsed_output)

TypeScript

import { z } from "zod";
import { zodOutputFormat } from "@anthropic-ai/sdk/helpers/zod";

const client = new Anthropic();

const APIResponseSchema = z.object({
  status: z.string(),
  data: z.record(z.string(), z.any()),
  errors: z.array(z.record(z.string(), z.any())).optional(),
  metadata: z.record(z.string(), z.any())
});

const response = await client.messages.parse({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  output_config: { format: zodOutputFormat(APIResponseSchema) },
  messages: [{ role: "user", content: "Process this request..." }]
});

console.log(response.parsed_output);

C#

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Messages = [new UserMessageParam { Content = "Process this request: ..." }],
    OutputConfig = new OutputConfig
    {
        Format = new JsonOutputFormat
        {
            Schema = new Dictionary<string, JsonElement>
            {
                ["type"] = JsonSerializer.SerializeToElement("object"),
                ["properties"] = JsonSerializer.SerializeToElement(new
                {
                    status = new { type = "string" },
                    data = new { type = "object", additionalProperties = false },
                    errors = new
                    {
                        type = "array",
                        items = new { type = "object", additionalProperties = false },
                    },
                    metadata = new { type = "object", additionalProperties = false },
                }),
                ["required"] = JsonSerializer.SerializeToElement(new[] { "status", "data", "metadata" }),
                ["additionalProperties"] = JsonSerializer.SerializeToElement(false),
            },
        },
    },
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);

Go

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	OutputConfig: anthropic.OutputConfigParam{
		Format: anthropic.JSONOutputFormatParam{
			Schema: map[string]any{
				"type":                 "object",
				"additionalProperties": false,
				"properties": map[string]any{
					"status": map[string]any{
						"type": "string",
					},
					"data": map[string]any{
						"type":                 "object",
						"additionalProperties": false,
					},
					"errors": map[string]any{
						"type": "array",
						"items": map[string]any{
							"type":                 "object",
							"additionalProperties": false,
						},
					},
					"metadata": map[string]any{
						"type":                 "object",
						"additionalProperties": false,
					},
				},
				"required": []string{"status", "data", "metadata"},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Process this request: ...")),
	},
})
if err != nil {
	log.Fatal(err)
}
for _, block := range response.Content {
	switch variant := block.AsAny().(type) {
	case anthropic.TextBlock:
		fmt.Println(variant.Text)
	}
}

Java

import com.fasterxml.jackson.annotation.JsonProperty;

static class APIData {
    @JsonProperty("message")
    public String message;

    @JsonProperty("resource_id")
    public String resourceId;
}

static class APIError {
    @JsonProperty("code")
    public String code;

    @JsonProperty("message")
    public String message;
}

static class APIMetadata {
    @JsonProperty("request_id")
    public String requestId;

    @JsonProperty("timestamp")
    public String timestamp;
}

static class APIResponse {
    @JsonProperty("status")
    public String status;

    @JsonProperty("data")
    public APIData data;

    @JsonProperty("errors")
    public List<APIError> errors;

    @JsonProperty("metadata")
    public APIMetadata metadata;
}

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    StructuredMessageCreateParams<APIResponse> params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024L)
        .outputConfig(APIResponse.class)
        .addUserMessage("Process this request: ...")
        .build();

    StructuredMessage<APIResponse> response = client.messages().create(params);
    APIResponse result = response.content().stream()
        .flatMap(block -> block.text().stream())
        .findFirst().orElseThrow().text();
    IO.println(result.status);
}

PHP

use Anthropic\Lib\Attributes\Constrained;
use Anthropic\Lib\Concerns\StructuredOutputModelTrait;
use Anthropic\Lib\Contracts\StructuredOutputModel;

$client = new Client();

class Payload implements StructuredOutputModel { use StructuredOutputModelTrait; public string $message; }

class APIError implements StructuredOutputModel { use StructuredOutputModelTrait; public string $code; public string $detail; }

class Metadata implements StructuredOutputModel { use StructuredOutputModelTrait; public string $request_id; }

class APIResponse implements StructuredOutputModel
{
    use StructuredOutputModelTrait;

    public string $status;
    public Payload $data;
    #[Constrained(itemClass: APIError::class)]
    public ?array $errors;
    public Metadata $metadata;
}

$message = $client->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => 'Process this request: ...']
    ],
    model: 'claude-opus-5-5',
    outputConfig: ['format' => APIResponse::class],
);

$result = $message->parsedOutput();
if ($result instanceof APIResponse) {
    echo "{$result->status}: {$result->data->message}\n";
}

Ruby

client = Anthropic::Client.new

class Payload < Anthropic::BaseModel
  required :message, String
end

class APIError < Anthropic::BaseModel
  required :code, String
  required :detail, String
end

class Metadata < Anthropic::BaseModel
  required :request_id, String
end

class APIResponse < Anthropic::BaseModel
  required :status, String
  required :data, Payload
  optional :errors, Anthropic::ArrayOf[APIError]
  required :metadata, Metadata
end

message = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  output_config: {format: APIResponse},
  messages: [
    {role: "user", content: "Process this request: ..."}
  ]
)
puts message.parsed_output