Anthropic-compatible Messages API | Model Studio - Alibaba Cloud Model Studio: Central de Documentação do Alibaba Cloud

Migre sua aplicação Anthropic para o Model Studio alterando três configurações. Este tópico aborda os parâmetros de requisição e resposta com exemplos de código.

Para migrar uma aplicação Anthropic existente para o Model Studio, altere estas configurações:

api_key: Substitua pela Model Studio API key.
base_url: Substitua por um endpoint do Model Studio listado abaixo.
model: Substitua pelo nome de um modelo suportado, como qwen3.7-plus.

ImportanteO Alibaba Cloud Model Studio lançou domínios específicos por workspace para as regiões China (Beijing), Singapore e China (Hong Kong). Os novos domínios dedicados oferecem desempenho superior e maior estabilidade para requisições de inferência. Recomendamos a migração para os novos domínios:

China (Beijing): de https://dashscope.aliyuncs.com para https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com
Singapore: de https://dashscope-intl.aliyuncs.com para https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com
China (Hong Kong): de https://cn-hongkong.dashscope.aliyuncs.com para https://{WorkspaceId}.cn-hongkong.maas.aliyuncs.com

{WorkspaceId} é o ID do seu workspace, disponível na página Workspace Details no console do Alibaba Cloud Model Studio. O domínio existente permanece totalmente funcional.

Singapore

SDK base_url:https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic

URL da requisição HTTP:POST https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages

China (Beijing)

SDK base_url:https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/apps/anthropic

URL da requisição HTTP:POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/apps/anthropic/v1/messages

Germany (Frankfurt)

SDK base_url:https://{WorkspaceId}.eu-central-1.maas.aliyuncs.com/apps/anthropic

URL da requisição HTTP:POST https://{WorkspaceId}.eu-central-1.maas.aliyuncs.com/apps/anthropic/v1/messages

US (Virginia)

SDK base_url:https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/apps/anthropic

URL da requisição HTTP:POST https://{WorkspaceId}.us-east-1.maas.aliyuncs.com/apps/anthropic/v1/messages

Japan (Tokyo)

SDK base_url:https://{WorkspaceId}.ap-northeast-1.maas.aliyuncs.com/apps/anthropic

URL da requisição HTTP:POST https://{WorkspaceId}.ap-northeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages

Substitua {WorkspaceId} pelo seu workspace ID real.

Autenticação: Informe sua Model Studio API key no header x-api-key ou no header Authorization: Bearer.

Request Body

Basic Call

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    message = client.messages.create(
        model="qwen3.8-max",
        max_tokens=1024,
        system="You are a helpful assistant",
        messages=[
            {
                "role": "user",
                "content": "Who are you?"
            }
        ],
        thinking={"type": "disabled"},
    )

    print(message.content[0].text)

TypeScript

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

    const anthropic = new Anthropic({
      apiKey: process.env.DASHSCOPE_API_KEY,
      // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    });

    async function main() {
      const message = await anthropic.messages.create({
        model: "qwen3.8-max",
        max_tokens: 1024,
        system: "You are a helpful assistant",
        messages: [{
          role: "user",
          content: "Who are you?"
        }],
        thinking: { type: "disabled" },
      });

      console.log(message.content[0].text);
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 1024,
        "system": "You are a helpful assistant",
        "messages": [
            {
                "role": "user",
                "content": "Who are you?"
            }
        ],
        "thinking": {"type": "disabled"}
    }'

Streaming

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    stream = client.messages.create(
        model="qwen3.8-max",
        max_tokens=1024,
        stream=True,
        messages=[
            {
                "role": "user",
                "content": "Give a brief introduction to artificial intelligence."
            }
        ],
        thinking={"type": "disabled"},
    )

    for chunk in stream:
        if chunk.type == "content_block_delta":
            if hasattr(chunk.delta, 'text'):
                print(chunk.delta.text, end="", flush=True)

TypeScript

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

    async function main() {
      const anthropic = new Anthropic({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
      });

      const stream = await anthropic.messages.create({
        model: "qwen3.8-max",
        max_tokens: 1024,
        stream: true,
        messages: [{
          role: "user",
          content: "Give a brief introduction to artificial intelligence."
        }],
        thinking: { type: "disabled" },
      });

      for await (const chunk of stream) {
        if (chunk.type === "content_block_delta" && 'text' in chunk.delta) {
          process.stdout.write(chunk.delta.text);
        }
      }
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      --no-buffer \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 1024,
        "stream": true,
        "messages": [
            {
                "role": "user",
                "content": "Give a brief introduction to artificial intelligence."
            }
        ],
        "thinking": {"type": "disabled"}
    }'

Extended Thinking

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    stream = client.messages.create(
        model="qwen3.8-max",
        max_tokens=2048,
        stream=True,
        thinking={
            "type": "enabled",
            "budget_tokens": 1024
        },
        messages=[
            {
                "role": "user",
                "content": "Analyze the future prospects of quantum computing."
            }
        ]
    )

    for chunk in stream:
        if chunk.type == "content_block_delta":
            if hasattr(chunk.delta, 'thinking'):
                print(chunk.delta.thinking, end="", flush=True)
            elif hasattr(chunk.delta, 'text'):
                print(chunk.delta.text, end="", flush=True)

TypeScript

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

    async function main() {
      const anthropic = new Anthropic({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
      });

      const stream = await anthropic.messages.create({
        model: "qwen3.8-max",
        max_tokens: 2048,
        stream: true,
        thinking: { type: "enabled", budget_tokens: 1024 },
        messages: [{
          role: "user",
          content: "Analyze the future prospects of quantum computing."
        }]
      });

      for await (const chunk of stream) {
        if (chunk.type === "content_block_delta") {
          if ('thinking' in chunk.delta) {
            process.stdout.write(chunk.delta.thinking);
          } else if ('text' in chunk.delta) {
            process.stdout.write(chunk.delta.text);
          }
        }
      }
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 2048,
        "stream": true,
        "thinking": {
            "type": "enabled",
            "budget_tokens": 1024
        },
        "messages": [
            {
                "role": "user",
                "content": "Analyze the future prospects of quantum computing."
            }
        ]
    }'

Image Understanding

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    stream = client.messages.create(
        model="qwen3.8-max",
        max_tokens=1024,
        stream=True,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "url",
                            "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250414/mqqmiy/animal_01.jpg",
                        },
                    },
                    {
                        "type": "text",
                        "text": "Describe the content of this image."
                    },
                ],
            }
        ],
        thinking={"type": "disabled"},
    )

    for chunk in stream:
        if chunk.type == "content_block_delta":
            if hasattr(chunk.delta, 'text'):
                print(chunk.delta.text, end="", flush=True)

TypeScript

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

    async function main() {
      const anthropic = new Anthropic({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
      });

      const stream = await anthropic.messages.create({
        model: "qwen3.8-max",
        max_tokens: 1024,
        stream: true,
        messages: [{
          role: "user",
          content: [
            {
              type: "image",
              source: {
                type: "url",
                url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250414/mqqmiy/animal_01.jpg",
              },
            },
            { type: "text", text: "Describe the content of this image." },
          ],
        }],
        thinking: { type: "disabled" },
      });

      for await (const chunk of stream) {
        if (chunk.type === "content_block_delta" && 'text' in chunk.delta) {
          process.stdout.write(chunk.delta.text);
        }
      }
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 1024,
        "stream": true,
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "image",
                        "source": {
                            "type": "url",
                            "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250414/mqqmiy/animal_01.jpg"
                        }
                    },
                    {
                        "type": "text",
                        "text": "Describe the content of this image."
                    }
                ]
            }
        ],
        "thinking": {"type": "disabled"}
    }'

Video Understanding

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    stream = client.messages.create(
        model="qwen3.8-max",
        max_tokens=1024,
        stream=True,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "video",
                        "source": {
                            "type": "url",
                            "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251208/zpupby/3e81ef38-98f0-4d55-bbb6-259334ca18d0.mp4",
                        },
                    },
                    {
                        "type": "text",
                        "text": "Describe the content of this video."
                    },
                ],
            }
        ],
        thinking={"type": "disabled"},
    )

    for chunk in stream:
        if chunk.type == "content_block_delta":
            if hasattr(chunk.delta, 'text'):
                print(chunk.delta.text, end="", flush=True)

TypeScript

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

    async function main() {
      const anthropic = new Anthropic({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
      });

      const stream = await anthropic.messages.create({
        model: "qwen3.8-max",
        max_tokens: 1024,
        stream: true,
        messages: [{
          role: "user",
          content: [
            {
              type: "video",
              source: {
                type: "url",
                url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251208/zpupby/3e81ef38-98f0-4d55-bbb6-259334ca18d0.mp4",
              },
            },
            { type: "text", text: "Describe the content of this video." },
          ],
        }],
        thinking: { type: "disabled" },
      });

      for await (const chunk of stream) {
        if (chunk.type === "content_block_delta" && 'text' in chunk.delta) {
          process.stdout.write(chunk.delta.text);
        }
      }
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 1024,
        "stream": true,
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "video",
                        "source": {
                            "type": "url",
                            "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20251208/zpupby/3e81ef38-98f0-4d55-bbb6-259334ca18d0.mp4"
                        }
                    },
                    {
                        "type": "text",
                        "text": "Describe the content of this video."
                    }
                ]
            }
        ],
        "thinking": {"type": "disabled"}
    }'

Function calling

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    tools = [
        {
            "name": "get_weather",
            "description": "Get weather information for a specified city",
            "input_schema": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name"
                    }
                },
                "required": ["city"]
            }
        }
    ]

    message = client.messages.create(
        model="qwen3.8-max",
        max_tokens=1024,
        tools=tools,
        messages=[
            {
                "role": "user",
                "content": "What's the weather like in Hangzhou today?"
            }
        ]
    )

    print(message.content)

TypeScript

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

    async function main() {
      const anthropic = new Anthropic({
        apiKey: process.env.DASHSCOPE_API_KEY,
        // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
      });

      const message = await anthropic.messages.create({
        model: "qwen3.8-max",
        max_tokens: 1024,
        tools: [
          {
            name: "get_weather",
            description: "Get weather information for a specified city",
            input_schema: {
              type: "object",
              properties: {
                city: { type: "string", description: "City name" }
              },
              required: ["city"],
            },
          },
        ],
        messages: [{
          role: "user",
          content: "What's the weather like in Hangzhou today?"
        }],
      });

      console.log(JSON.stringify(message.content, null, 2));
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 1024,
        "tools": [
            {
                "name": "get_weather",
                "description": "Get weather information for a specified city",
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "city": {
                            "type": "string",
                            "description": "City name"
                        }
                    },
                    "required": ["city"]
                }
            }
        ],
        "messages": [
            {
                "role": "user",
                "content": "What's the weather like in Hangzhou today?"
            }
        ]
    }'

Prompt Caching

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    # Simulate code repository content. Must reach minimum cacheable length (1024 tokens)
    long_text_content = "<Your Code Here>" * 400

    def get_completion(user_input):
        response = client.messages.create(
            # Choose a model that supports prompt caching
            model="qwen3.8-max",
            max_tokens=1024,
            system=[
                {
                    "type": "text",
                    "text": long_text_content,
                    # Add cache_control on a text block to mark a cache breakpoint. Can also be placed on content blocks in the messages array
                    "cache_control": {"type": "ephemeral"},
                }
            ],
            messages=[
                {"role": "user", "content": user_input},
            ],
        )
        return response

    # First request: Create cache
    first = get_completion("What does this code do?")
    print(f"Cache creation tokens: {first.usage.cache_creation_input_tokens}")
    print(f"Cache read tokens: {first.usage.cache_read_input_tokens}")
    print("=" * 20)
    # Second request: Same long content, different question -> Cache hit
    second = get_completion("How can this code be optimized?")
    print(f"Cache creation tokens: {second.usage.cache_creation_input_tokens}")
    print(f"Cache read tokens: {second.usage.cache_read_input_tokens}")

TypeScript

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

    const client = new Anthropic({
      apiKey: process.env.DASHSCOPE_API_KEY,
      // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    });

    // Simulate code repository content. Must reach minimum cacheable length (1024 tokens)
    const longTextContent = "<Your Code Here>".repeat(400);

    async function getCompletion(userInput) {
      return client.messages.create({
        // Choose a model that supports prompt caching
        model: "qwen3.8-max",
        max_tokens: 1024,
        system: [
          {
            type: "text",
            text: longTextContent,
            // Add cache_control on a text block to mark a cache breakpoint. Can also be placed on content blocks in the messages array
            cache_control: { type: "ephemeral" },
          },
        ],
        messages: [{ role: "user", content: userInput }],
      });
    }

    // First request: Create cache
    const first = await getCompletion("What does this code do?");
    console.log(`Cache creation tokens: ${first.usage.cache_creation_input_tokens}`);
    console.log(`Cache read tokens: ${first.usage.cache_read_input_tokens}`);
    console.log("=".repeat(20));
    // Second request: Same long content, different question -> Cache hit
    const second = await getCompletion("How can this code be optimized?");
    console.log(`Cache creation tokens: ${second.usage.cache_creation_input_tokens}`);
    console.log(`Cache read tokens: ${second.usage.cache_read_input_tokens}`);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "qwen3.8-max",
        "max_tokens": 1024,
        "system": [
          {
            "type": "text",
            "text": "<Place cacheable content here with at least 1024 tokens>",
            "cache_control": {"type": "ephemeral"}
          }
        ],
        "messages": [
          {"role": "user", "content": "What does this code do?"}
        ]
    }'

Structured Outputs

Python

import anthropic
    import os

    client = anthropic.Anthropic(
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
        base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    )

    message = client.messages.create(
        model="deepseek-v4-pro",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": "Extract key info from this email: John Smith (john@example.com) is interested in the Enterprise plan and wants to schedule a demo for next Tuesday at 2pm."
            }
        ],
        extra_body={
            "output_config": {
                "format": {
                    "type": "json_schema",
                    "schema": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string"},
                            "email": {"type": "string"},
                            "plan_interest": {"type": "string"},
                            "demo_requested": {"type": "boolean"}
                        },
                        "required": ["name", "email", "plan_interest", "demo_requested"],
                        "additionalProperties": False
                    }
                }
            }
        },
    )

    # deepseek-v4-pro returns a thinking block; find the text content block
    text_block = next(block for block in message.content if block.type == "text")
    print(text_block.text)

TypeScript

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

    const anthropic = new Anthropic({
      apiKey: process.env.DASHSCOPE_API_KEY,
      // Replace {WorkspaceId} with your actual workspace ID. URLs vary by region.
      baseURL: "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic",
    });

    async function main() {
      // output_config is a Model Studio platform extension parameter, pass via body
      const message = await (anthropic.messages.create as Function)({
        model: "deepseek-v4-pro",
        max_tokens: 1024,
        messages: [{
          role: "user",
          content: "Extract key info from this email: John Smith (john@example.com) is interested in the Enterprise plan and wants to schedule a demo for next Tuesday at 2pm."
        }],
        output_config: {
          format: {
            type: "json_schema",
            schema: {
              type: "object",
              properties: {
                name: { type: "string" },
                email: { type: "string" },
                plan_interest: { type: "string" },
                demo_requested: { type: "boolean" }
              },
              required: ["name", "email", "plan_interest", "demo_requested"],
              additionalProperties: false
            }
          }
        }
      });

      // deepseek-v4-pro returns a thinking block; find the text content block
      const textBlock = message.content.find(
        (block: { type: string }) => block.type === "text"
      );
      console.log(textBlock?.text);
    }

    main().catch(console.error);

curl

curl -X POST "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages" \
      -H "Content-Type: application/json" \
      -H "x-api-key: $DASHSCOPE_API_KEY" \
      -d '{
        "model": "deepseek-v4-pro",
        "max_tokens": 1024,
        "messages": [
            {
                "role": "user",
                "content": "Extract key info from this email: John Smith (john@example.com) is interested in the Enterprise plan and wants to schedule a demo for next Tuesday at 2pm."
            }
        ],
        "output_config": {
            "format": {
                "type": "json_schema",
                "schema": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "email": {"type": "string"},
                        "plan_interest": {"type": "string"},
                        "demo_requested": {"type": "boolean"}
                    },
                    "required": ["name", "email", "plan_interest", "demo_requested"],
                    "additionalProperties": false
                }
            }
        }
    }'

model string (Required)

Nome do modelo. Modelos suportados:

Supported Models

Qwen-Max: qwen3.8-max, qwen3.7-max, qwen3.7-max-2026-05-20, qwen3.7-max-2026-06-08

Qwen-Plus: qwen3.7-plus, qwen3.7-plus-2026-05-26, qwen3.6-plus, qwen3.6-plus-2026-04-02, qwen3.5-plus, qwen3.5-plus-2026-04-20, qwen3.5-plus-2026-02-15, qwen-plus, qwen-plus-latest

Qwen-Flash: qwen3.8-flash, qwen3.7-flash, qwen3.7-flash-2026-07-15, qwen3.6-flash, qwen3.6-flash-2026-04-16, qwen3.5-flash, qwen3.5-flash-2026-02-23, qwen-flash, qwen-flash-2025-07-28

Qwen-Coder: qwen3-coder-flash

Qwen-VL: qwen3-vl-plus

Qwen Open-Source Models: qwen3.6-27b, qwen3.5-397b-a17b, qwen3.5-122b-a10b, qwen3.5-27b, qwen3.5-35b-a3b, qwen3.8-2.4t-a95b, qwen3.8-27b

Third-Party Models

deepseek-v4-pro, deepseek-v4-pro-0813, deepseek-v4-flash-0731, kimi-k3.1-pro, kimi-k3, kimi-k2.7-code, kimi-k2.5, glm-5.1, glm-5, MiniMax-M2.5, deepseek-v4.1-flash-1017

max_tokens integer (Required)

deepseek-v4-pro, deepseek-v4-pro-0813, deepseek-v4-flash-0731, qwen3.8-max: max_tokens representa o limite total de tokens para o conteúdo da resposta e para a cadeia de pensamento. A geração é interrompida antecipadamente quando a saída do modelo excede esse valor, e stop_reason assume o valor max_tokens.

max_tokens limita o comprimento combinado do conteúdo da resposta e do processo de raciocínio. Quando o extended thinking está ativado, max_tokens > thinking.budget_tokens
glm-5.2: Se o parâmetro thinking.budget_tokens não for passado, max_tokens define o limite total de tokens para o conteúdo da resposta e da cadeia de pensamento. A geração para antes se a saída ultrapassar esse limite, resultando em stop_reason igual a max_tokens. Caso o parâmetro thinking.budget_tokens seja fornecido, max_tokens restringe apenas os tokens da resposta final, enquanto os tokens de raciocínio são controlados separadamente por thinking.budget_tokens.
Demais modelos: Número máximo de tokens para o conteúdo da resposta. Se o conteúdo gerado ultrapassar esse valor, a geração cessa prematuramente e stop_reason retorna max_tokens.

max_tokens não limita a extensão do processo de raciocínio. Com o extended thinking habilitado, os tokens de pensamento são gerenciados independentemente via thinking.budget_tokens.

system string or array (Optional)

Prompt de sistema que define o comportamento do modelo. system é um parâmetro de nível superior — o array messages não aceita a função system.

Uma string equivale a um único bloco type="text". Utilize um array para marcar pontos de interrupção de cache de prompt.

Properties

type string (Required)

Valor fixo: text.

text string (Required)

O texto do prompt de sistema.

cache_control object (Optional)

Ponto de interrupção para cache de prompt. Em caso de acerto de cache, as requisições subsequentes são cobradas pela taxa de leitura de cache. Contém apenas type, fixado em ephemeral.

messages array (Required)

O array de mensagens, organizado em turnos alternados de user/assistant.

messages array element

role string (Required)

A função da mensagem. Valores válidos: user, assistant.

content string or array (Required)

String de texto simples ou array de conteúdo estruturado. Uma string corresponde a um único bloco de content com type="text".

content array element types

Text

Properties

type string (Required)

Valor fixo: text.

text string (Required)

O conteúdo textual.

cache_control object (Optional)

Ponto de interrupção para cache de prompt. Contém apenas type, fixado em ephemeral.

Image (requer modelo de visão)

Properties

type string (Required)

Valor fixo: image.

source object (Required)

A origem dos dados da imagem.

Properties

type string (Required)

Valores válidos: url (URL pública da imagem), base64 (codificado em Base64).

url string

A URL pública da imagem. Obrigatório quando type for url.

media_type string

O tipo MIME da imagem, como image/jpeg. Obrigatório quando type for base64.

data string

Os dados da imagem codificados em Base64. Obrigatório quando type for base64.

Video (requer modelo de visão)

Properties

type string (Required)

Valor fixo: video.

source object (Required)

A origem dos dados de vídeo.

Properties

type string (Required)

Valores válidos: url (URL pública do vídeo), base64 (codificado em Base64).

url string

A URL pública do vídeo. Obrigatório quando type for url.

media_type string

O tipo MIME do vídeo, como video/mp4. Obrigatório quando type for base64.

data string

Os dados do vídeo codificados em Base64. Obrigatório quando type for base64.

Tool use (função assistant; instrução de chamada de ferramenta retornada pelo modelo)

Properties

type string (Required)

Valor fixo: tool_use.

id string (Required)

Identificador único da chamada de ferramenta, usado para associar o resultado em um tool_result subsequente.

name string (Required)

O nome da ferramenta invocada.

input object (Required)

Os parâmetros de entrada da chamada de ferramenta. A estrutura é determinada pelo input_schema da ferramenta correspondente em tools.

cache_control object (Optional)

Ponto de interrupção para cache de prompt. Contém apenas type, fixado em ephemeral. O conteúdo da chamada de ferramenta participa do prefixo de cache.

Tool result (função user; resultado da execução de uma ferramenta enviado de volta ao modelo)

Properties

type string (Required)

Valor fixo: tool_result.

tool_use_id string (Required)

Corresponde ao id no bloco tool_use.

content string (Required)

Conteúdo retornado pela ferramenta.

cache_control object (Optional)

Ponto de interrupção para cache de prompt. Contém apenas type, fixado em ephemeral.

stream boolean (Optional)

Ativa ou desativa o streaming. Valor padrão: false.

temperature number (Optional)

Controla a diversidade do texto gerado. Intervalo de valores: [0, 2). Valores mais altos produzem resultados mais aleatórios.

ObservaçãoEste intervalo difere do intervalo oficial da Anthropic, que é [0,0, 1,0]. Ao migrar da Anthropic, verifique o valor deste parâmetro.

top_p number (Optional)

Limiar de probabilidade para amostragem nuclear.

Tanto temperature quanto top_p podem controlar a diversidade do texto gerado. Recomendamos configurar apenas um deles. Para mais informações, consulte Overview.

top_k integer (Optional)

Tamanho do conjunto de candidatos durante a amostragem.

stop_sequences array (Optional)

Sequências de texto que acionam a parada da geração. A saída termina antes da sequência correspondente.

ObservaçãoApós uma correspondência, o stop_reason na resposta ainda será end_turn, e a resposta não incluirá a sequência encontrada.

thinking object (Optional)

kimi-k3.1-pro ativa o pensamento por padrão.

Configuração de extended thinking. Quando ativado, o modelo raciocina antes de responder, e a resposta inclui blocos de conteúdo do tipo thinking. Nem todos os modelos suportam o modo de raciocínio.

Properties

type string (Required)

Valores válidos: enabled (ativa o modo de raciocínio), disabled (desativa o modo de raciocínio).

budget_tokens integer (Optional, to be deprecated)

Este parâmetro será descontinuado. Para novas integrações, utilize effort.

Máximo de tokens para o processo de raciocínio. Independente de max_tokens: este parâmetro limita a parte de raciocínio, enquanto max_tokens limita a resposta final. Um orçamento maior permite análises mais detalhadas em questões complexas. Entra em vigor quando type é enabled.

tools array (Optional)

Definições de ferramentas para function calling.

tools array element

name string (Required)

O nome da ferramenta.

description string (Optional)

A descrição da função da ferramenta.

input_schema object (Required)

A definição JSON Schema dos parâmetros de entrada da ferramenta.

kimi-k3.1-pro (implantado no Alibaba Cloud Model Studio) suporta web_search e web_fetch em Pequim, Singapura, EUA (Virgínia), Alemanha (Frankfurt), Japão (Tóquio) e China (Hong Kong).

deepseek-v4.1-flash-1017 suporta as ferramentas de pesquisa na web web_search e de obtenção de páginas web web_fetch. Para os requisitos e exemplos de requisições compatíveis com Anthropic, consulte Extrator web.

tool_choice object (Optional)

Estratégia de seleção de ferramentas:

{"type": "auto"}: O modelo decide se deve chamar uma ferramenta (padrão).
{"type": "any"}: Força o modelo a chamar qualquer ferramenta disponível.
{"type": "none"}: Proíbe o modelo de chamar ferramentas.
{"type": "tool", "name": "tool_name"}: Obriga o modelo a chamar uma ferramenta específica.

output_config object (Optional)

Properties

effort string (Optional)

Controla a intensidade de inferência dos modelos. Os valores válidos e padrões variam conforme o modelo.

Para kimi-k3.1-pro (implantado no Alibaba Cloud Model Studio), o padrão é max. Os valores suportados são max (raciocínio profundo), high (raciocínio aprimorado), medium (raciocínio moderado) e low (raciocínio leve).

glm-5.2 e deepseek-v4-pro: Valor padrão: max

Valores válidos:
- high: Inferência de alta intensidade
- max: Inferência de intensidade máxima
low e medium são mapeados para high, e xhigh é mapeado para max.
qwen3.8-max: Valor padrão: xhigh

Valores válidos:
- xhigh: Inferência de alta intensidade
- medium: Inferência de média intensidade
- low: Inferência de baixa intensidade
max e high são mapeados para xhigh.

format object (Optional)

Configuração de saída estruturada. Quando habilitada, o modelo retorna uma string JSON. O comportamento varia conforme o modelo:

deepseek-v4.1-flash e deepseek-v4.1-flash-1017 não suportam este parâmetro e retornam um erro 400 se ele for especificado.

Saídas estruturadas estritas: Disponível para as séries qwen3.8, qwen3.7, deepseek (exceto deepseek-v4.1-flash, deepseek-v4.1-flash-1017, deepseek-v4-flash-0731 e deepseek-v4-pro-0813) e glm. O modelo segue rigorosamente o JSON Schema fornecido, garantindo os mesmos tipos de campos e hierarquia.
Saídas estruturadas regulares: Para todos os outros modelos, as restrições de campo do schema não são aplicadas — a API reverte automaticamente para um modo JSON simples (garantindo apenas que a saída seja uma string JSON válida). Neste modo de fallback, a requisição deve satisfazer ambas as condições: (1) o parâmetro output_config deve ser explicitamente fornecido; (2) o conteúdo de system ou messages deve conter a palavra-chave "JSON" (insensível a maiúsculas/minúsculas). Se a palavra-chave "JSON" estiver ausente, a API lançará o erro: 'messages' must contain the word 'json' in some form.

Properties

type string (Required)

Valor fixo: json_schema.

schema object (Required)

Objeto JSON Schema que segue a especificação padrão. Deve incluir type (tipo de dado), properties (definições de campos), required (array de nomes de campos obrigatórios) e additionalProperties (deve ser definido como false).

Non-streaming Response

Response Example

{
  "id": "msg_e2898f19-fc0e-4cb3-bd9b-5b7dc4ea3bc9",
  "type": "message",
  "role": "assistant",
  "model": "qwen3.8-max",
  "content": [
    {
      "type": "thinking",
      "thinking": "Let me analyze this problem...",
      "signature": ""
    },
    {
      "type": "text",
      "text": "Hello! I am Qwen..."
    }
  ],
  "stop_reason": "end_turn",
  "stop_sequence": null,
  "usage": {
    "input_tokens": 22,
    "output_tokens": 223,
    "cache_creation_input_tokens": 0,
    "cache_read_input_tokens": 0
  }
}

id string

Identificador único da mensagem.

type string

Valor fixo: message.

role string

Valor fixo: assistant.

model string

O modelo utilizado para geração.

content array

O array de conteúdo.

content array element types

Text

Properties

type string

Valor fixo: text.

text string

A resposta textual gerada pelo modelo.

Thinking (retornado quando Extended Thinking está ativado)

Properties

type string

Valor fixo: thinking.

thinking string

O raciocínio do modelo antes da resposta final.

signature string

Atualmente fixado como uma string vazia.

Tool use (cenário de chamada de função)

Properties

type string

Valor fixo: tool_use.

id string

Identificador único da chamada de ferramenta, usado para corresponder ao tool_result.

name string

O nome da ferramenta invocada.

input object

Os parâmetros de entrada da chamada de ferramenta.

stop_reason string

Motivo da interrupção da geração. Valores válidos: end_turn (conclusão normal), max_tokens (limite de tokens atingido), tool_use (chamada de ferramenta).

stop_sequence string

Sempre null.

usage object

Estatísticas de uso de tokens.

ObservaçãoEm chamadas com streaming, o campo usage do evento message_start contém apenas input_tokens e output_tokens. Os quatro campos completos são retornados no evento message_delta.

Properties

input_tokens integer

Tokens de entrada.

output_tokens integer

Tokens de saída.

cache_creation_input_tokens integer

Tokens consumidos para criação de cache.

cache_read_input_tokens integer

Tokens consumidos em leituras de cache.

Streaming Response

Streaming response example

{"type":"message_start","message":{"id":"msg_xxx","type":"message","role":"assistant","model":"qwen3.8-max","content":[],"usage":{"input_tokens":15,"output_tokens":0}}}
{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"","signature":""}}
{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":"Here's a thinking process:\n\n1. **Analyze User Input:**\n   - **Topic:** Artificial Intelligence (AI)\n   - **Request:** Give a brief introduction to artificial intelligence."}}
{"type":"content_block_delta","index":0,"delta":{"type":"signature_delta","signature":""}}
{"type":"content_block_stop","index":0}
{"type":"content_block_start","index":1,"content_block":{"type":"text","text":""}}
{"type":"content_block_delta","index":1,"delta":{"type":"text_delta","text":"Artificial intelligence (AI) is an important branch of computer science..."}}
{"type":"content_block_stop","index":1}
{"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"input_tokens":15,"output_tokens":1078,"cache_creation_input_tokens":0,"cache_read_input_tokens":0}}
{"type":"message_stop"}

message_start

Primeiro evento do fluxo, marca o início da mensagem.

Properties

type string

Valor fixo: message_start.

message object

O objeto inicial da mensagem. content é um array vazio, e usage contém apenas input_tokens e output_tokens.

content_block_start

Marca o início de um bloco de conteúdo.

Properties

type string

Valor fixo: content_block_start.

index integer

Índice baseado em zero correspondente à posição no array content.

content_block object

O objeto inicial do bloco de conteúdo. O valor de type é text, thinking ou tool_use. Para o tipo tool_use, o campo input é um objeto vazio neste evento, e os parâmetros de entrada completos são montados a partir dos deltas content_block_delta subsequentes.

content_block_delta

Atualização incremental do bloco de conteúdo. Múltiplos deltas são enviados por bloco.

Properties

type string

Valor fixo: content_block_delta.

index integer

O índice do bloco de conteúdo associado.

delta object

Objeto delta. Valores de type:

text_delta: Delta de texto, contendo o campo text.
thinking_delta: Delta de raciocínio, contendo o campo thinking.
signature_delta: Delta de assinatura, contendo o campo signature (atualmente fixado como string vazia).
input_json_delta: Delta de parâmetro de entrada de ferramenta, contendo o campo partial_json.

content_block_stop

Marca o fim de um bloco de conteúdo.

Properties

type string

Valor fixo: content_block_stop.

index integer

O índice do bloco de conteúdo finalizado.

message_delta

Enviado após o término de todos os blocos de conteúdo. Contém o motivo da parada e o uso final de tokens.

Properties

type string

Valor fixo: message_delta.

delta object

Contém stop_reason e stop_sequence. Para valores válidos, consulte a tabela de Resposta Sem Streaming acima.

usage object

Estatísticas completas de uso de tokens, incluindo input_tokens, output_tokens, cache_creation_input_tokens e cache_read_input_tokens.

message_stop

Evento final, marca o encerramento da mensagem.

Properties

type string

Valor fixo: message_stop.

Além disso, respostas em streaming enviam periodicamente eventos de ping ({"type":"ping"}) para manter a conexão ativa. Os clientes podem ignorá-los.

FAQ

Após configurar o Claude Desktop ou Claude Code, o teste de conexão falha comModel discovery — Gateway /v1/models returned HTTP 404, ou a URL da requisição contém/v1/v1/models. Como resolver?

O recurso de descoberta de modelos de clientes como Claude Desktop e Claude Code adiciona automaticamente /v1/models à URL base configurada. Verifique os dois pontos a seguir:

Não termine a URL base com/v1/: ela deve terminar em /apps/anthropic (por exemplo, para China (Beijing) use https://dashscope.aliyuncs.com/apps/anthropic; consulte as informações de endpoint acima para outras regiões). Se você inserir incorretamente .../apps/anthropic/v1/, o cliente anexará /v1/models e produzirá o caminho duplicado /v1/v1/models, que retorna HTTP 404. Portanto, ao receber um erro 404, verifique primeiro se a URL real da requisição contém um /v1/v1/ duplicado; nesse caso, remova o /v1/ final da URL base.
Adicione modelos manualmente para pular a descoberta: o endpoint compatível com Anthropic do Model Studio fornece apenas a Messages API (/v1/messages) e não oferece um endpoint de lista de modelos (/v1/models), logo a requisição de descoberta também retorna 404. Adicione modelos manualmente (por exemplo, qwen3.7-plus) na seção Models do cliente para evitar a descoberta automática.