Migrate your Anthropic application to Model Studio by changing three settings. This topic covers the request and response parameters with code examples.
To migrate an existing Anthropic application to Model Studio, change these settings:
base_url: Replace with a Model Studio endpoint listed below.
model: Replace with a supported model name, such as qwen3.7-plus.
ImportantAlibaba Cloud Model Studio has released workspace-specific domains for the China (Beijing), Singapore regions. The new dedicated domains deliver superior performance and higher stability for inference requests. We recommend migrating to the new domains:
China (Beijing): from https://dashscope.aliyuncs.com to https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com
Singapore: from https://dashscope-intl.aliyuncs.com to https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com
{WorkspaceId} is your workspace ID, which can be found on the Workspace Details page in the Alibaba Cloud Model Studio console. The existing domain remains fully functional.
deepseek-v4-pro, deepseek-v4-pro-0813, deepseek-v4-flash, deepseek-v4-flash-0731, qwen3.8-max, qwen3.8-flash: max_tokens is the maximum total token count for both the reply content and the chain-of-thought content. Generation stops early when the model output exceeds this value, and stop_reason is max_tokens.
max_tokens limits the combined length of reply content and the thinking process. When extended thinking is enabled, max_tokens > thinking.budget_tokens
glm-5.2: When the thinking.budget_tokens parameter is not passed, max_tokens is the maximum total token count for both the reply content and the chain-of-thought content. Generation stops early when the model output exceeds this value, and stop_reason is max_tokens. When the thinking.budget_tokens parameter is passed, max_tokens is only the maximum number of tokens for the reply content, and the thinking tokens are controlled separately by thinking.budget_tokens.
Other models: Maximum number of tokens for the reply content. If the generated content exceeds this value, generation stops early and stop_reason is max_tokens.
max_tokens does not limit the length of the thinking process. When extended thinking is enabled, the thinking tokens are controlled separately by thinking.budget_tokens.
systemstring or array (Optional)
System prompt that defines model behavior. system is a top-level parameter — the messages array does not accept a system role.
A string equals a single type="text" block. Pass an array to mark prompt caching breakpoints.
Properties
typestring(Required)
Fixed value: text.
textstring(Required)
The system prompt text.
cache_controlobject (Optional)
Prompt caching breakpoint. On cache hit, subsequent requests are billed at the cache read rate. Contains only type, fixed to ephemeral.
messagesarray(Required)
The message array, arranged in alternating user/assistant turns.
messages array element
rolestring(Required)
The message role. Valid values: user, assistant.
contentstring or array(Required)
Plain text string or structured content array. A string equals a single content block with type="text".
content array element types
Text
Properties
typestring(Required)
Fixed value: text.
textstring(Required)
The text content.
cache_controlobject (Optional)
Prompt caching breakpoint. Contains only type, fixed to ephemeral.
The public URL of the image. Required when type is url.
media_typestring
The MIME type of the image, such as image/jpeg. Required when type is base64.
datastring
The Base64-encoded image data. Required when type is base64.
Video (requires vision model)
Properties
typestring(Required)
Fixed value: video.
sourceobject(Required)
The source of the video data.
Properties
typestring(Required)
Valid values: url (public video URL), base64 (Base64-encoded).
urlstring
The public URL of the video. Required when type is url.
media_typestring
The MIME type of the video, such as video/mp4. Required when type is base64.
datastring
The Base64-encoded video data. Required when type is base64.
Tool use (assistant role; tool call instruction returned by the model)
Properties
typestring(Required)
Fixed value: tool_use.
idstring(Required)
The unique identifier of the tool call, used to associate the result in a subsequent tool_result.
namestring(Required)
The name of the called tool.
inputobject(Required)
The input parameters of the tool call. The structure is determined by the input_schema of the corresponding tool in tools.
cache_controlobject (Optional)
Prompt caching breakpoint. Contains only type, fixed to ephemeral. The tool call content participates in the cache prefix.
Tool result (user role; execution result of a tool sent back to the model)
Properties
typestring(Required)
Fixed value: tool_result.
tool_use_idstring(Required)
Corresponds to the id in the tool_use block.
contentstring(Required)
Content returned by the tool.
cache_controlobject (Optional)
Prompt caching breakpoint. Contains only type, fixed to ephemeral.
streamboolean (Optional)
Whether to enable streaming. Default value: false.
temperaturenumber (Optional)
Controls the diversity of generated text. Value range: [0, 2). Higher values produce more random results.
NoteThis range is different from the official Anthropic range of [0.0, 1.0]. When migrating from Anthropic, verify the value of this parameter.
top_pnumber (Optional)
Nucleus sampling probability threshold.
Both temperature and top_p can control the diversity of generated text. We recommend setting only one of them. For more information, see Overview.
top_kinteger (Optional)
Candidate set size during sampling.
stop_sequencesarray (Optional)
Text sequences that trigger generation to stop. Output ends before the matched sequence.
NoteAfter a match, the stop_reason in the response is still end_turn, and the response does not include the matched sequence.
thinkingobject (Optional)
Extended thinking configuration. When enabled, the model reasons before responding, and the response includes thinking-type content blocks. Not all models support thinking mode.
This parameter will be deprecated. For new integrations, use effort.
Maximum tokens for the thinking process. Disjoint from max_tokens: this parameter limits the thinking portion, while max_tokens limits the final reply. A larger budget allows more thorough analysis on complex questions. Takes effect when type is enabled.
toolsarray (Optional)
Tool definitions for function calling.
tools array element
namestring(Required)
The tool name.
descriptionstring (Optional)
The description of the tool function.
input_schemaobject(Required)
The JSON Schema definition of the tool input parameters.
tool_choiceobject (Optional)
Tool selection strategy:
{"type": "auto"}: The model decides whether to call a tool (default).
{"type": "any"}: Force the model to call any tool.
{"type": "none"}: Prohibit the model from calling tools.
{"type": "tool", "name": "tool_name"}: Force the model to call a specified tool.
output_configobject (Optional)
Properties
effortstring (Optional)
Controls the inference intensity of models. The valid values and default values vary by model.
glm-5.2, deepseek-v4-pro, and deepseek-v4-flash(supplied by Alibaba Cloud): Default value: max
Valid values:
high: High-intensity inference
max: Maximum-intensity inference
low and medium are mapped to high, and xhigh is mapped to max.
qwen3.8-max/qwen3.8-flash: Default value: xhigh
Valid values:
xhigh: High-intensity inference
medium: Medium-intensity inference
low: Low-intensity inference
max, high are mapped to xhigh.
formatobject (Optional)
Structured output configuration. When enabled, the model returns a JSON string. Behavior varies by model:
Strict structured outputs: Available for qwen3.8, qwen3.7, deepseek, and glm series models. The model strictly follows the provided JSON Schema, guaranteeing the same field types and hierarchy.
Regular structured outputs: For all other models, schema field constraints are not enforced — the API automatically falls back to a plain JSON mode (only guaranteeing that the output is a valid JSON string). In this fallback mode, the request must satisfy both of the following: (1) the output_config parameter is explicitly provided; (2) the system or messages content contains the keyword "JSON" (case-insensitive). If the keyword "JSON" is missing, the API throws: 'messages' must contain the word 'json' in some form.
Properties
typestring(Required)
Fixed value: json_schema.
schemaobject(Required)
JSON Schema object that follows the standard JSON Schema specification. Should include type (data type), properties (field definitions), required (array of required field names), and additionalProperties (must be set to false).
Basic Call
import anthropic
import os
client = anthropic.Anthropic(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.cn-beijing.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)
import Anthropic from "@anthropic-ai/sdk";
const anthropic = new Anthropic({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.cn-beijing.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 -X POST "https://{WorkspaceId}.cn-beijing.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
import anthropic
import os
client = anthropic.Anthropic(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.cn-beijing.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)
import Anthropic from "@anthropic-ai/sdk";
async function main() {
const anthropic = new Anthropic({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.cn-beijing.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);
import anthropic
import os
client = anthropic.Anthropic(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.cn-beijing.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)
import Anthropic from "@anthropic-ai/sdk";
async function main() {
const anthropic = new Anthropic({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.cn-beijing.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 -X POST "https://{WorkspaceId}.cn-beijing.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
import anthropic
import os
client = anthropic.Anthropic(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.cn-beijing.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}")
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.cn-beijing.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 -X POST "https://{WorkspaceId}.cn-beijing.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
import anthropic
import os
client = anthropic.Anthropic(
api_key=os.getenv("DASHSCOPE_API_KEY"),
base_url="https://{WorkspaceId}.cn-beijing.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)
import Anthropic from "@anthropic-ai/sdk";
const anthropic = new Anthropic({
apiKey: process.env.DASHSCOPE_API_KEY,
baseURL: "https://{WorkspaceId}.cn-beijing.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 -X POST "https://{WorkspaceId}.cn-beijing.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
}
}
}
}'
Non-streaming Response
idstring
Unique message identifier.
typestring
Fixed value: message.
rolestring
Fixed value: assistant.
modelstring
The model used for generation.
contentarray
The content array.
content array element types
Text
Properties
typestring
Fixed value: text.
textstring
The text response generated by the model.
Thinking (returned when Extended Thinking is enabled)
Properties
typestring
Fixed value: thinking.
thinkingstring
The model's reasoning before the final response.
signaturestring
Currently fixed as an empty string.
Tool use (function call scenario)
Properties
typestring
Fixed value: tool_use.
idstring
Unique tool call identifier, used to match the tool_result.
NoteIn streaming calls, the usage field of the message_start event contains only input_tokens and output_tokens. The full four fields are returned in the message_delta event.
The initial message object. content is an empty array, and usage contains only input_tokens and output_tokens.
content_block_start
Marks the start of a content block.
Properties
typestring
Fixed value: content_block_start.
indexinteger
0-based index corresponding to position in the content array.
content_blockobject
The initial object of the content block. The type value is text, thinking, or tool_use. For the tool_use type, the input field is an empty object in this event, and the complete input parameters are assembled from subsequent content_block_delta deltas.
content_block_delta
Incremental content block update. Multiple deltas sent per block.
Properties
typestring
Fixed value: content_block_delta.
indexinteger
The index of the associated content block.
deltaobject
Delta object. type values:
text_delta: Text delta, containing the text field.
thinking_delta: Thinking delta, containing the thinking field.
signature_delta: Signature delta, containing the signature field (currently fixed as an empty string).
input_json_delta: Tool call input parameter delta, containing the partial_json field.
content_block_stop
Marks the end of a content block.
Properties
typestring
Fixed value: content_block_stop.
indexinteger
The index of the ended content block.
message_delta
Sent after all content blocks end. Contains stop reason and final token usage.
Properties
typestring
Fixed value: message_delta.
deltaobject
Contains stop_reason and stop_sequence. For valid values, see the Non-streaming Response table above.
usageobject
Complete token usage statistics, including input_tokens, output_tokens, cache_creation_input_tokens, and cache_read_input_tokens.
message_stop
Final event, marks message end.
Properties
typestring
Fixed value: message_stop.
In addition, streaming responses periodically send ping events ({"type":"ping"}) to keep the connection alive. Clients can ignore them.
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"}
FAQ
After configuring Claude Desktop or Claude Code, the connection test fails withModel discovery — Gateway /v1/models returned HTTP 404, or the request URL contains/v1/v1/models. How do I fix it?
The model discovery feature of clients such as Claude Desktop and Claude Code automatically appends /v1/models to the configured base URL. Check the following two points:
Do not end the base URL with/v1/: it should end at /apps/anthropic (for example, for China (Beijing) use https://dashscope.aliyuncs.com/apps/anthropic; see the endpoint information above for other regions). If you mistakenly enter .../apps/anthropic/v1/, the client appends /v1/models and produces the duplicated path /v1/v1/models, which returns HTTP 404. Therefore, when you get a 404, first check whether the actual request URL contains a duplicated /v1/v1/; if so, remove the trailing /v1/ from the base URL.
Add models manually to skip discovery: the Model Studio Anthropic-compatible endpoint provides only the Messages API (/v1/messages) and does not provide a model list endpoint (/v1/models), so the model discovery request returns 404 as well. Manually add models (for example, qwen3.7-plus) under Models in the client to skip automatic discovery.