API Messages compatible Anthropic | Model Studio - Alibaba Cloud Model Studio

Migrez votre application Anthropic vers Model Studio en modifiant trois paramètres. Cette rubrique détaille les paramètres de requête et de réponse, avec des exemples de code.

Pour migrer une application Anthropic existante vers Model Studio, modifiez les paramètres suivants :

api_key : Remplacez cette valeur par la clé API Model Studio.
base_url : Utilisez un endpoint Model Studio listé ci-dessous.
model : Spécifiez le nom d'un modèle pris en charge, tel que qwen3.7-plus.

ImportantAlibaba Cloud Model Studio a publié des domaines spécifiques à chaque espace de travail pour les régions Chine (Pékin), Singapour et Chine (Hong Kong). Ces nouveaux domaines dédiés offrent des performances supérieures et une stabilité accrue pour les requêtes d'inférence. Nous vous recommandons de migrer vers ces nouveaux domaines :

Chine (Pékin) : passez de https://dashscope.aliyuncs.com à https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com
Singapour : passez de https://dashscope-intl.aliyuncs.com à https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com
Chine (Hong Kong) : passez de https://cn-hongkong.dashscope.aliyuncs.com à https://{WorkspaceId}.cn-hongkong.maas.aliyuncs.com

{WorkspaceId} correspond à l'ID de votre espace de travail, disponible sur la page Workspace Details dans la console Alibaba Cloud Model Studio. Le domaine existant reste pleinement fonctionnel.

Singapore

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

URL de requête 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 de requête 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 de requête 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 de requête 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 de requête HTTP :POST https://{WorkspaceId}.ap-northeast-1.maas.aliyuncs.com/apps/anthropic/v1/messages

Remplacez {WorkspaceId} par votre ID d'espace de travail.

Authentification : Transmettez votre clé API Model Studio via l'en-tête x-api-key ou Authorization: Bearer.

Corps de la requête

Appel de base

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"}
    }'

Réflexion étendue

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."
            }
        ]
    }'

Compréhension d'images

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"}
    }'

Compréhension vidéo

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"}
    }'

Appel de fonction

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?"
            }
        ]
    }'

Mise en cache du prompt

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?"}
        ]
    }'

Sorties structurées

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 (Obligatoire)

Nom du modèle. Modèles pris en charge :

Modèles pris en charge

Qwen-Max : qwen3.8-max, qwen3.7-max, qwen3.7-max-2026-05-20, qwen3.7-max-2026-06-08, qwen3.6-max-preview, qwen3-max, qwen3-max-2026-01-23, qwen3-max-preview

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-plus-2025-09-11

Qwen-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-Turbo : qwen-turbo

Qwen-Coder : qwen3-coder-next, qwen3-coder-plus, qwen3-coder-plus-2025-09-23, qwen3-coder-flash

Qwen-VL : qwen3-vl-plus, qwen3-vl-flash, qwen-vl-max, qwen-vl-plus

Modèles open source Qwen : qwen3.6-27b, qwen3.5-397b-a17b, qwen3.5-122b-a10b, qwen3.5-27b, qwen3.5-35b-a3b

Modèles tiers

deepseek-v4-pro, deepseek-v4-flash, deepseek-v4-flash-0731, deepseek-v3.2, kimi-k2.7-code, kimi-k2.6, kimi-k2.5, kimi-k2-thinking, glm-5.2, glm-5.1, glm-5, glm-4.7, glm-4.6, MiniMax-M2.5, MiniMax-M2.1

max_tokens integer (Obligatoire)

deepseek-v4-pro, deepseek-v4-flash, deepseek-v4-flash-0731, qwen3.8-max : max_tokens définit le nombre maximal total de tokens pour le contenu de la réponse et la chaîne de pensée. La génération s'arrête prématurément si la sortie du modèle dépasse cette valeur, et stop_reason prend la valeur max_tokens.

max_tokens limite la longueur combinée du contenu de la réponse et du processus de réflexion. Lorsque la réflexion étendue est activée, max_tokens > thinking.budget_tokens
glm-5.2 : Sans le paramètre thinking.budget_tokens, max_tokens définit le nombre maximal total de tokens pour le contenu de la réponse et la chaîne de pensée. La génération s'arrête prématurément si la sortie du modèle dépasse cette valeur, et stop_reason prend la valeur max_tokens. Avec le paramètre thinking.budget_tokens, max_tokens limite uniquement le contenu de la réponse, tandis que thinking.budget_tokens contrôle séparément les tokens de réflexion.
Autres modèles : Nombre maximal de tokens pour le contenu de la réponse. Si le contenu généré dépasse cette valeur, la génération s'arrête prématurément et stop_reason prend la valeur max_tokens.

max_tokens ne limite pas la longueur du processus de réflexion. Lorsque la réflexion étendue est activée, thinking.budget_tokens contrôle séparément les tokens de réflexion.

system string or array (Facultatif)

Prompt système définissant le comportement du modèle. system est un paramètre de niveau supérieur ; le tableau messages n'accepte pas le rôle system.

Une chaîne équivaut à un seul bloc type="text". Transmettez un tableau pour marquer des points d'arrêt de mise en cache du prompt.

Propriétés

type string (Obligatoire)

Valeur fixe : text.

text string (Obligatoire)

Texte du prompt système.

cache_control object (Facultatif)

Point d'arrêt de mise en cache du prompt. En cas de succès du cache, les requêtes suivantes sont facturées au tarif de lecture du cache. Contient uniquement type, fixé à ephemeral.

messages array (Obligatoire)

Tableau des messages, organisé en tours alternés user/assistant.

Élément du tableau messages

role string (Obligatoire)

Rôle du message. Valeurs valides : user, assistant.

content string or array (Obligatoire)

Chaîne de texte brut ou tableau de contenu structuré. Une chaîne équivaut à un seul bloc content avec type="text".

Types d'éléments du tableau content

Texte

Propriétés

type string (Obligatoire)

Valeur fixe : text.

text string (Obligatoire)

Contenu textuel.

cache_control object (Facultatif)

Point d'arrêt de mise en cache du prompt. Contient uniquement type, fixé à ephemeral.

Image (nécessite un modèle visuel)

Propriétés

type string (Obligatoire)

Valeur fixe : image.

source object (Obligatoire)

Source des données de l'image.

Propriétés

type string (Obligatoire)

Valeurs valides : url (URL d'image publique), base64 (encodé en Base64).

url string

URL publique de l'image. Obligatoire lorsque type est url.

media_type string

Type MIME de l'image, par exemple image/jpeg. Obligatoire lorsque type est base64.

data string

Données de l'image encodées en Base64. Obligatoire lorsque type est base64.

Vidéo (nécessite un modèle visuel)

Propriétés

type string (Obligatoire)

Valeur fixe : video.

source object (Obligatoire)

Source des données vidéo.

Propriétés

type string (Obligatoire)

Valeurs valides : url (URL vidéo publique), base64 (encodé en Base64).

url string

URL publique de la vidéo. Obligatoire lorsque type est url.

media_type string

Type MIME de la vidéo, par exemple video/mp4. Obligatoire lorsque type est base64.

data string

Données vidéo encodées en Base64. Obligatoire lorsque type est base64.

Utilisation d'outil (rôle assistant ; instruction d'appel d'outil renvoyée par le modèle)

Propriétés

type string (Obligatoire)

Valeur fixe : tool_use.

id string (Obligatoire)

Identifiant unique de l'appel d'outil, utilisé pour associer le résultat dans un tool_result ultérieur.

name string (Obligatoire)

Nom de l'outil appelé.

input object (Obligatoire)

Paramètres d'entrée de l'appel d'outil. La structure dépend du input_schema de l'outil correspondant dans tools.

cache_control object (Facultatif)

Point d'arrêt de mise en cache du prompt. Contient uniquement type, fixé à ephemeral. Le contenu de l'appel d'outil participe au préfixe du cache.

Résultat d'outil (rôle user ; résultat d'exécution d'un outil renvoyé au modèle)

Propriétés

type string (Obligatoire)

Valeur fixe : tool_result.

tool_use_id string (Obligatoire)

Correspond à l'id du bloc tool_use.

content string (Obligatoire)

Contenu renvoyé par l'outil.

cache_control object (Facultatif)

Point d'arrêt de mise en cache du prompt. Contient uniquement type, fixé à ephemeral.

stream boolean (Facultatif)

Active ou désactive le streaming. Valeur par défaut : false.

temperature number (Facultatif)

Contrôle la diversité du texte généré. Plage de valeurs : [0, 2). Des valeurs plus élevées produisent des résultats plus aléatoires.

RemarqueCette plage diffère de la plage officielle d'Anthropic ([0,0, 1,0]). Lors d'une migration depuis Anthropic, vérifiez la valeur de ce paramètre.

top_p number (Facultatif)

Seuil de probabilité pour l'échantillonnage par noyau.

temperature et top_p contrôlent tous deux la diversité du texte généré. Nous recommandons de n'en définir qu'un seul. Pour plus d'informations, consultez la rubrique Vue d'ensemble.

top_k integer (Facultatif)

Taille de l'ensemble de candidats lors de l'échantillonnage.

stop_sequences array (Facultatif)

Séquences de texte déclenchant l'arrêt de la génération. La sortie se termine avant la séquence correspondante.

RemarqueAprès une correspondance, stop_reason dans la réponse conserve la valeur end_turn, et la réponse n'inclut pas la séquence détectée.

thinking object (Facultatif)

Configuration de la réflexion étendue. Lorsqu'elle est activée, le modèle raisonne avant de répondre et la réponse inclut des blocs de contenu de type thinking. Tous les modèles ne prennent pas en charge le mode réflexion.

Propriétés

type string (Obligatoire)

Valeurs valides : enabled (activer le mode réflexion), disabled (désactiver le mode réflexion).

budget_tokens integer (Facultatif)

Nombre maximal de tokens pour le processus de réflexion. Indépendant de max_tokens : ce paramètre limite la partie réflexion, tandis que max_tokens limite la réponse finale. Un budget plus élevé permet une analyse plus approfondie des questions complexes. Prend effet lorsque type est enabled.

tools array (Facultatif)

Définitions d'outils pour l'appel de fonction.

Élément du tableau tools

name string (Obligatoire)

Nom de l'outil.

description string (Facultatif)

Description de la fonction de l'outil.

input_schema object (Obligatoire)

Définition JSON Schema des paramètres d'entrée de l'outil.

tool_choice object (Facultatif)

Stratégie de sélection d'outil :

{"type": "auto"} : Le modèle décide s'il doit appeler un outil (par défaut).
{"type": "any"} : Force le modèle à appeler n'importe quel outil.
{"type": "none"} : Interdit au modèle d'appeler des outils.
{"type": "tool", "name": "tool_name"} : Force le modèle à appeler un outil spécifique.

output_config object (Facultatif)

Propriétés

effort string (Facultatif)

Contrôle l'intensité d'inférence des modèles. Les valeurs valides et les valeurs par défaut varient selon le modèle. Valeur par défaut : max.

Valeurs valides :

high : Inférence haute intensité
max : Inférence intensité maximale

low et medium correspondent à high, et xhigh correspond à max.

Modèles pris en charge : qwen3.8-max, glm-5.2, deepseek-v4-pro et deepseek-v4-flash.

format object (Facultatif)

Configuration des sorties structurées. Lorsqu'elle est activée, le modèle renvoie une chaîne JSON. Le comportement varie selon le modèle :

Sorties structurées strictes : Disponible pour les modèles des séries deepseek et glm. Le modèle suit strictement le schéma JSON fourni, garantissant les mêmes types de champs et la même hiérarchie.
Sorties structurées standard : Pour tous les autres modèles, les contraintes de champs du schéma ne sont pas appliquées. L'API bascule automatiquement vers un mode JSON simple (garantissant uniquement que la sortie est une chaîne JSON valide). Dans ce mode de repli, la requête doit satisfaire aux deux conditions suivantes : (1) le paramètre output_config est explicitement fourni ; (2) le contenu de system ou de messages contient le mot-clé « JSON » (insensible à la casse). Si le mot-clé « JSON » est absent, l'API renvoie l'erreur : 'messages' must contain the word 'json' in some form.

Propriétés

type string (Obligatoire)

Valeur fixe : json_schema.

schema object (Obligatoire)

Objet JSON Schema conforme à la spécification standard. Doit inclure type (type de données), properties (définitions des champs), required (tableau des noms de champs obligatoires) et additionalProperties (doit être défini sur false).

Réponse non-streaming

Exemple de réponse

{
  "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

Identifiant unique du message.

type string

Valeur fixe : message.

role string

Valeur fixe : assistant.

model string

Modèle utilisé pour la génération.

content array

Tableau de contenu.

Types d'éléments du tableau content

Texte

Propriétés

type string

Valeur fixe : text.

text string

Réponse textuelle générée par le modèle.

Réflexion (renvoyé lorsque la réflexion étendue est activée)

Propriétés

type string

Valeur fixe : thinking.

thinking string

Raisonnement du modèle avant la réponse finale.

signature string

Actuellement fixée à une chaîne vide.

Utilisation d'outil (scénario d'appel de fonction)

Propriétés

type string

Valeur fixe : tool_use.

id string

Identifiant unique de l'appel d'outil, utilisé pour faire correspondre le tool_result.

name string

Nom de l'outil appelé.

input object

Paramètres d'entrée de l'appel d'outil.

stop_reason string

Raison de l'arrêt de la génération. Valeurs valides : end_turn (achèvement normal), max_tokens (limite de tokens atteinte), tool_use (appel d'outil).

stop_sequence string

Toujours null.

usage object

Statistiques d'utilisation des tokens.

RemarqueDans les appels en streaming, le champ usage de l'événement message_start contient uniquement input_tokens et output_tokens. Les quatre champs complets sont renvoyés dans l'événement message_delta.

Propriétés

input_tokens integer

Tokens d'entrée.

output_tokens integer

Tokens de sortie.

cache_creation_input_tokens integer

Tokens consommés pour la création du cache.

cache_read_input_tokens integer

Tokens consommés par les lectures du cache.

Réponse en streaming

Exemple de réponse en streaming

{"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

Premier événement du flux, marque le début du message.

Propriétés

type string

Valeur fixe : message_start.

message object

Objet message initial. content est un tableau vide, et usage contient uniquement input_tokens et output_tokens.

content_block_start

Marque le début d'un bloc de contenu.

Propriétés

type string

Valeur fixe : content_block_start.

index integer

Index basé sur 0 correspondant à la position dans le tableau content.

content_block object

Objet initial du bloc de contenu. La valeur de type est text, thinking ou tool_use. Pour le type tool_use, le champ input est un objet vide dans cet événement, et les paramètres d'entrée complets sont assemblés à partir des deltas content_block_delta suivants.

content_block_delta

Mise à jour incrémentielle du bloc de contenu. Plusieurs deltas sont envoyés par bloc.

Propriétés

type string

Valeur fixe : content_block_delta.

index integer

Index du bloc de contenu associé.

delta object

Objet delta. Valeurs de type :

text_delta : Delta de texte, contenant le champ text.
thinking_delta : Delta de réflexion, contenant le champ thinking.
signature_delta : Delta de signature, contenant le champ signature (actuellement fixé à une chaîne vide).
input_json_delta : Delta de paramètre d'entrée d'appel d'outil, contenant le champ partial_json.

content_block_stop

Marque la fin d'un bloc de contenu.

Propriétés

type string

Valeur fixe : content_block_stop.

index integer

Index du bloc de contenu terminé.

message_delta

Envoyé après la fin de tous les blocs de contenu. Contient la raison d'arrêt et l'utilisation finale des tokens.

Propriétés

type string

Valeur fixe : message_delta.

delta object

Contient stop_reason et stop_sequence. Pour les valeurs valides, reportez-vous au tableau Réponse non-streaming ci-dessus.

usage object

Statistiques complètes d'utilisation des tokens, incluant input_tokens, output_tokens, cache_creation_input_tokens et cache_read_input_tokens.

message_stop

Dernier événement, marque la fin du message.

Propriétés

type string

Valeur fixe : message_stop.

De plus, les réponses en streaming envoient périodiquement des événements ping ({"type":"ping"}) pour maintenir la connexion active. Les clients peuvent les ignorer.

FAQ

Après avoir configuré Claude Desktop ou Claude Code, le test de connexion échoue avecModel discovery — Gateway /v1/models returned HTTP 404, ou l'URL de requête contient/v1/v1/models. Comment résoudre ce problème ?

La fonctionnalité de découverte de modèles des clients tels que Claude Desktop et Claude Code ajoute automatiquement /v1/models à l'URL de base configurée. Vérifiez les deux points suivants :

Ne terminez pas l'URL de base par/v1/ : elle doit se terminer par /apps/anthropic (par exemple, pour Chine (Pékin), utilisez https://dashscope.aliyuncs.com/apps/anthropic ; consultez les informations d'endpoint ci-dessus pour les autres régions). Si vous saisissez par erreur .../apps/anthropic/v1/, le client ajoute /v1/models et produit le chemin dupliqué /v1/v1/models, ce qui renvoie une erreur HTTP 404. Par conséquent, si vous obtenez une erreur 404, vérifiez d'abord si l'URL de requête réelle contient un doublon /v1/v1/ ; le cas échéant, supprimez le /v1/ final de l'URL de base.
Ajoutez manuellement des modèles pour ignorer la découverte : L'endpoint compatible Anthropic de Model Studio fournit uniquement l'API Messages (/v1/messages) et ne propose pas d'endpoint de liste de modèles (/v1/models), de sorte que la requête de découverte de modèles renvoie également une erreur 404. Ajoutez manuellement des modèles (par exemple, qwen3.7-plus) sous Models dans le client pour contourner la découverte automatique.