Make your first API call to Qwen-Alibaba Cloud Model Studio(Model Studio)-阿里云帮助中心

Account setup

Create an account: If you do not have an Alibaba Cloud account, create one.

If you encounter issues, see Register an Alibaba Cloud account.
Activate Model Studio: Use your Alibaba Cloud account to go to Alibaba Cloud Model Studio. Read and accept the Terms of Service to activate the service. If no Terms of Service dialog appears, the service is already activated.

If you see the message “You have not completed identity verification” when activating the service, complete identity verification first.
Get an API key: Go to the API Key page and click Create API key. Then use the API key to call models.
Get your workspace ID: When calling models in the China (Beijing), Singapore, or Germany (Frankfurt) region, you need to include the workspace ID (WorkspaceId) in the Base URL. You can find it on the Workspace Management page.

Set your API key as an environment variable

Store your API key in an environment variable to avoid hardcoding credentials and reduce security risks.

Steps

Linux

Permanent environment variable

To make the API key available in all future sessions, export it permanently.

Run the following command to add the environment variable to the ~/.bashrc file:
```
# Replace YOUR_DASHSCOPE_API_KEY with your API key.
echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.bashrc
```
You can also edit the ~/.bashrc file manually.
Edit manually
Run the following command to open the ~/.bashrc file.
```
nano ~/.bashrc
```
Add the following content to the file.
```
# Replace YOUR_DASHSCOPE_API_KEY with your API key.
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
```
In the nano editor, press Ctrl+X and then Y. Press Enter to save and close the file.
Run the following command to make the change take effect:
```
source ~/.bashrc
```
Create a session and run the following command to check whether the environment variable takes effect:
```
echo $DASHSCOPE_API_KEY
```

Temporary environment variable

To use the API key only in the current session, export it temporarily.

Run the following command:

# Replace YOUR_DASHSCOPE_API_KEY with your API key.
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

Run the following command to check whether the environment variable takes effect:
```
echo $DASHSCOPE_API_KEY
```

macOS

Permanent environment variable

To make the API key available in all future sessions, export it permanently.

Run the following command to check the default Shell type.
```
echo $SHELL
```
Perform the following operation based on your Shell type.
Zsh
1. Run the following command to add the environment variable to the ~/.zshrc file.
```
# Replace YOUR_DASHSCOPE_API_KEY with your API key.
echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.zshrc
```
  You can also edit the ~/.zshrc file manually.
  Edit manually
  
  Run the following command to open the configuration file.
  nano ~/.zshrc
  
  Add the following content to the file.
  # Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
  
  In the nano editor, press Ctrl+X and then Y. Press Enter to save and close the file.
2. Run the following command to make the change take effect:
```
source ~/.zshrc
```
3. Create a session and run the following command to check whether the environment variable takes effect:
```
echo $DASHSCOPE_API_KEY
```
Bash
1. Run the following command to add the environment variable to the ~/.bash_profile file.
```
# Replace YOUR_DASHSCOPE_API_KEY with your API key.
echo "export DASHSCOPE_API_KEY='YOUR_DASHSCOPE_API_KEY'" >> ~/.bash_profile
```
  You can also edit the ~/.bash_profile file manually.
  Edit manually
  
  Run the following command to open the file.
  nano ~/.bash_profile
  
  Add the following content to the file.
  # Replace YOUR_DASHSCOPE_API_KEY with your API key. export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"
  
  In the nano editor, press Ctrl+X and then Y. Press Enter to save and close the file.
2. Run the following command to make the change take effect:
```
source ~/.bash_profile
```
3. Create a session and run the following command to check whether the environment variable takes effect:
```
echo $DASHSCOPE_API_KEY
```

Temporary environment variable

To use the API key only in the current session, export it temporarily.

The following commands work only for Zsh and Bash.

Run the following command:

# Replace YOUR_DASHSCOPE_API_KEY with your API key.
export DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

Run the following command to check whether the environment variable takes effect:
```
echo $DASHSCOPE_API_KEY
```

Windows

In Windows, you can export environment variables using System Properties, Command Line, or PowerShell.

System Properties

Note

The environment variable configured in this way is permanently effective.
Modifying system environment variable requires administrative permissions.
After configuring the environment variable, it will not affect already-running programs. Restart IDEs and command windows, or open a new command line, to load the new variable.

Press Win+Q on your desktop. Enter "Edit the system environment variables" in the search box, and click to open the System Properties window.
In the System Properties window, click Environment Variables. In the System Variables section, click New, enter DASHSCOPE_API_KEY as the variable name, and your actual API Key as the variable value.
Click OK on all three dialog boxes.
Open CMD or Windows PowerShell and run the following command to check whether the environment variable takes effect.
- CMD:
```
echo %DASHSCOPE_API_KEY%
```
- Windows PowerShell:
```
echo $env:DASHSCOPE_API_KEY
```

CMD

Permanent environment variable

To make the API key available in all future sessions, export it permanently.

Run the following command:

# Replace YOUR_DASHSCOPE_API_KEY with your API key.
setx DASHSCOPE_API_KEY "YOUR_DASHSCOPE_API_KEY"

Create a new session.
Run the following command to check whether the environment variable takes effect:
```
echo %DASHSCOPE_API_KEY%
```

Temporary environment variable

To use the API key only in the current session, export it temporarily.

Run the following command:

# Replace YOUR_DASHSCOPE_API_KEY with your API key.
set DASHSCOPE_API_KEY="YOUR_DASHSCOPE_API_KEY"

Run the following command in the current session to check whether the environment variable takes effect:
```
echo %DASHSCOPE_API_KEY%
```

PowerShell

Permanent environment variable

To make the API key available in all future sessions, export it permanently.

Run the following command:

# Replace YOUR_DASHSCOPE_API_KEY with your API key.
[Environment]::SetEnvironmentVariable("DASHSCOPE_API_KEY", "YOUR_DASHSCOPE_API_KEY", [EnvironmentVariableTarget]::User)

Create a session.
Run the following command to check whether the environment variable takes effect:
```
echo $env:DASHSCOPE_API_KEY
```

Temporary environment variable

To use the API key only in the current session, export it temporarily.

Run the following command:

# Replace YOUR_DASHSCOPE_API_KEY with your API key.
$env:DASHSCOPE_API_KEY = "YOUR_DASHSCOPE_API_KEY"

Run the following command in the current session to check whether the environment variable takes effect:
```
echo $env:DASHSCOPE_API_KEY
```

Choose a development language

Select a language or tool to call model APIs.

Python

Step 1: Set up Python

Check your Python version

Run this command to check whether Python and pip are installed:

Python 3.8 or later is required. For installation instructions, see Install Python.

python -V
pip --version

For example, on Windows Command Prompt:

FAQ

Q: The commands python -V and pip --version return errors:

'python' is not recognized as an internal or external command, operable program or batch file.
'pip' is not recognized as an internal or external command, operable program or batch file.
-bash: python: command not found
-bash: pip: command not found

Try these solutions:

Windows

Confirm that you installed Python by following Install Python, and added python.exe to the PATH environment variable.
If Python and PATH are correctly configured but the error persists, close your current terminal and open a new one.

Linux and macOS

Confirm that you installed Python by following Install Python.
If Python is installed but the error persists, run which python pip to check whether python and pip exist in your system.
- If this result appears, close the current terminal window, open a new terminal window, and try again.
```
/usr/bin/python
/usr/bin/pip
```
- If this result is returned, run the which python3 pip3 query again.
```
/usr/bin/which: no python in (/root/.local/bin:/root/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin)
/usr/bin/which: no pip in (/root/.local/bin:/root/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin)
```
  If the returned result is shown, use python3 -V and pip3 --version to check the version.
```
/usr/bin/python3
/usr/bin/pip3
```

Set up a virtual environment (optional)

If Python is already installed, you can create a virtual environment to install the OpenAI Python SDK or the DashScope Python SDK and avoid dependency conflicts.

Create a virtual environment

Create a virtual environment named .venv:
```
# If this fails, replace python with python3
python -m venv .venv
```
Activate the virtual environment

On Windows, activate the virtual environment:
```
.venv\Scripts\activate
```
On macOS or Linux, run:
```
source .venv/bin/activate
```

Install the OpenAI Python SDK or DashScope Python SDK

You can call models on Model Studio using the OpenAI Python SDK or the DashScope Python SDK.

Install the OpenAI Python SDK

Install or upgrade the OpenAI Python SDK:

# If this fails, replace pip with pip3
pip install -U openai

Look for Successfully installed ... openai-x.x.x to confirm installation.

Install the DashScope Python SDK

Install or upgrade the DashScope Python SDK:

# If this fails, replace pip with pip3
pip install -U dashscope

Look for Successfully installed ... dashscope-x.x.x to confirm installation.

Step 2: Call the API

OpenAI Python SDK

With Python and the OpenAI Python SDK installed, send your first API request.

Create a file named hello_qwen.py.

Copy this code into hello_qwen.py and save it.

import os
from openai import OpenAI

try:
    client = OpenAI(
        # If the environment variable is not configured, replace with: api_key="sk-xxx"
        api_key=os.getenv("DASHSCOPE_API_KEY"),
        # The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
        base_url="https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1",
    )

    completion = client.chat.completions.create(
        model="qwen-plus",  # Model list: https://help.aliyun.com/model-studio/getting-started/models
        messages=[
            {'role': 'system', 'content': 'You are a helpful assistant.'},
            {'role': 'user', 'content': 'Who are you?'}
        ]
    )
    print(completion.choices[0].message.content)
except Exception as e:
    print(f"Error message: {e}")
    print("See: https://help.aliyun.com/model-studio/developer-reference/error-code")

Run python hello_qwen.py or python3 hello_qwen.py from the command line.

If you see No such file or directory, specify the full path to the file.

The output is:
```
I am a large-scale language model developed by Alibaba Cloud. My name is Qwen.
```

DashScope Python SDK

With Python and the DashScope Python SDK installed, send your first API request.

Create a file named hello_qwen.py.

Copy this code into hello_qwen.py and save it.

import os
from dashscope import Generation
import dashscope

# The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
dashscope.base_http_api_url = 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1'
messages = [
    {'role': 'system', 'content': 'You are a helpful assistant.'},
    {'role': 'user', 'content': 'Who are you?'}
]
response = Generation.call(
    # If the environment variable is not configured, replace with: api_key = "sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"), 
    model="qwen-plus",   # Model list: https://help.aliyun.com/model-studio/getting-started/models
    messages=messages,
    result_format="message"
)

if response.status_code == 200:
    print(response.output.choices[0].message.content)
else:
    print(f"HTTP status code: {response.status_code}")
    print(f"Error code: {response.code}")
    print(f"Error message: {response.message}")
    print("See: https://help.aliyun.com/model-studio/developer-reference/error-code")

Run python hello_qwen.py or python3 hello_qwen.py from the command line.

Note
The command in this example must be executed from the directory containing the Python file. To run it from elsewhere, specify the full path.

The output is:
```
I am a large-scale language model from Alibaba Cloud. My name is Qwen.
```

Node.js

Step 1: Set up your Node.js environment

Check your Node.js installation

Check whether Node.js and npm are installed:

node -v
npm -v

For example, on Windows Command Prompt:

This prints your current Node.js version. If Node.js is not installed, download it from the Node.js official website.

Install the model calling SDK

Run this command in your terminal:

npm install --save openai
# Or
yarn add openai

Note

If installation fails, configure a registry mirror:

npm config set registry https://registry.npmmirror.com/

After configuring the mirror, rerun the SDK installation command.

Look for added xx package in xxs to confirm installation. Check version: npm list openai.

Step 2: Call the model API

Create a file named hello_qwen.mjs.

Copy this code into the file.

import OpenAI from "openai";

try {
    const openai = new OpenAI(
        {
            // If the environment variable is not configured, replace with: apiKey: "sk-xxx"
            apiKey: process.env.DASHSCOPE_API_KEY,
            // The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
            baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1"
        }
    );
    const completion = await openai.chat.completions.create({
        model: "qwen-plus",  // Model list: https://help.aliyun.com/model-studio/getting-started/models
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "Who are you?" }
        ],
    });
    console.log(completion.choices[0].message.content);
} catch (error) {
    console.log(`Error message: ${error}`);
    console.log("See: https://help.aliyun.com/model-studio/developer-reference/error-code");
}

Run this command to send an API request.
```
node hello_qwen.mjs
```
Note
- Run this command from the directory containing hello_qwen.mjs. To run it from any location, specify the full path to the file.
- Ensure the SDK is installed in the same directory as hello_qwen.mjs. If they are in different directories, you will see Cannot find package 'openai' imported from xxx.
After successful execution, the output is:
```
I am a language model from Alibaba Cloud. My name is Qwen.
```

Java

Step 1: Set up your Java environment

Check your Java version

Run this command in your terminal:

java -version
# (Optional) If you use Maven to manage and build Java projects, ensure Maven is installed
mvn --version

For example, on Windows Command Prompt:

Java 8 or later is required for the DashScope Java SDK. For example, openjdk version "16.0.1" 2021-04-20 means Java 16. If Java is not installed or the version is below Java 8, download and install it from Java downloads.

Install the model calling SDK

Install the DashScope Java SDK. For the latest version, see DashScope Java SDK. Add this dependency, replacing the-latest-version with the latest version number.

XML

Open your Maven project's pom.xml file.

Add this dependency to the <dependencies> tag:

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dashscope-sdk-java</artifactId>
    <!-- Replace 'the-latest-version' with the latest version number: https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java -->
    <version>the-latest-version</version>
</dependency>

Save the pom.xml file.
Run a Maven command such as mvn compile or mvn clean install to update dependencies. Maven will automatically download and add the DashScope Java SDK to your project.

For example, in IntelliJ IDEA on Windows:

Gradle

Open your Gradle project's build.gradle file.

Add this dependency to the dependencies block:

dependencies {
    // Replace 'the-latest-version' with the latest version number: https://mvnrepository.com/artifact/com.alibaba/dashscope-sdk-java
    implementation group: 'com.alibaba', name: 'dashscope-sdk-java', version: 'the-latest-version'
}

Save the build.gradle file.
In your terminal, navigate to your project root directory and run this Gradle command to update dependencies. It will automatically download and add the DashScope Java SDK to your project.
```
./gradlew build --refresh-dependencies
```

For example, in IntelliJ IDEA on Windows:

Step 2: Call the API

Run this code to call the model API.

import java.util.Arrays;
import java.lang.System;
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.protocol.Protocol;

public class Main {
    public static GenerationResult callWithMessage() throws ApiException, NoApiKeyException, InputRequiredException {
        // The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
        Generation gen = new Generation(Protocol.HTTP.getValue(), "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1");
        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .content("You are a helpful assistant.")
                .build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content("Who are you?")
                .build();
        GenerationParam param = GenerationParam.builder()
                // If the environment variable is not configured, replace with: .apiKey("sk-xxx")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                // Model list: https://help.aliyun.com/model-studio/getting-started/models
                .model("qwen-plus")
                .messages(Arrays.asList(systemMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }
    public static void main(String[] args) {
        try {
            GenerationResult result = callWithMessage();
            System.out.println(result.getOutput().getChoices().get(0).getMessage().getContent());
        } catch (ApiException | NoApiKeyException | InputRequiredException e) {
            System.err.println("Error message: "+e.getMessage());
            System.out.println("See: https://help.aliyun.com/model-studio/developer-reference/error-code");
        }
        System.exit(0);
    }
}

The output is:

I am a large-scale language model developed by Alibaba Cloud. My name is Qwen.

curl

Call models on Model Studio using OpenAI-compatible or DashScope HTTP endpoints. For supported models, see Model list.

Note

If DASHSCOPE_API_KEY is not set, replace -H "Authorization: Bearer $DASHSCOPE_API_KEY" with -H "Authorization: Bearer sk-xxx".

OpenAI-compatible HTTP

Send the API request:

Windows

Run this command in Command Prompt:

curl -X POST "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions" ^
-H "Authorization: Bearer %DASHSCOPE_API_KEY%" ^
-H "Content-Type: application/json" ^
-d "{
    \"model\": \"qwen-plus\",
    \"messages\": [
        {
            \"role\": \"system\",
            \"content\": \"You are a helpful assistant.\"
        },
        {
            \"role\": \"user\",
            \"content\": \"Who are you?\"
        }
    ]
}"

Linux and macOS

Run this command in Terminal:

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "messages": [
        {
            "role": "system",
            "content": "You are a helpful assistant."
        },
        {
            "role": "user", 
            "content": "Who are you?"
        }
    ]
}'

After sending the API request, you receive this response:

{
    "choices": [
        {
            "message": {
                "role": "assistant",
                "content": "I am a large-scale language model from Alibaba Cloud. My name is Qwen."
            },
            "finish_reason": "stop",
            "index": 0,
            "logprobs": null
        }
    ],
    "object": "chat.completion",
    "usage": {
        "prompt_tokens": 22,
        "completion_tokens": 16,
        "total_tokens": 38
    },
    "created": 1728353155,
    "system_fingerprint": null,
    "model": "qwen-plus",
    "id": "chatcmpl-39799876-eda8-9527-9e14-2214d641cf9a"
}

DashScope HTTP

Send the API request:

Windows

Run this command in Command Prompt:

curl -X POST "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation" ^
-H "Authorization: Bearer %DASHSCOPE_API_KEY%" ^
-H "Content-Type: application/json" ^
-d "{
  \"model\": \"qwen-plus\",
  \"input\": {
    \"messages\": [
      {
        \"role\": \"system\",
        \"content\": \"You are a helpful assistant.\"
      },
      {
        \"role\": \"user\",
        \"content\": \"Who are you?\"
      }
    ]
  },
  \"parameters\": {
    \"result_format\": \"message\"
  }
}"

Linux and macOS

Run this command in Terminal:

curl -X POST https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/text-generation/generation \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
    "model": "qwen-plus",
    "input":{
        "messages":[      
            {
                "role": "system",
                "content": "You are a helpful assistant."
            },
            {
                "role": "user",
                "content": "Who are you?"
            }
        ]
    },
    "parameters": {
        "result_format":"message"
    }
}'

After sending the API request, you receive this response:

{
    "output": {
        "choices": [
            {
                "finish_reason": "stop",
                "message": {
                    "role": "assistant",
                    "content": "I am a large-scale language model from Alibaba Cloud. My name is Qwen."
                }
            }
        ]
    },
    "usage": {
        "total_tokens": 38,
        "output_tokens": 16,
        "input_tokens": 22
    },
    "request_id": "87f776d7-3c82-9d39-b238-d1ad38c9b6a9"
}

Other languages

Call the model API

Go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
)

type Message struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}
type RequestBody struct {
	Model    string    `json:"model"`
	Messages []Message `json:"messages"`
}

func main() {
	// Create an HTTP client
	client := &http.Client{}
	// Build the request body
	requestBody := RequestBody{
		// Model list: https://help.aliyun.com/model-studio/getting-started/models
		Model: "qwen-plus",
		Messages: []Message{
			{
				Role:    "system",
				Content: "You are a helpful assistant.",
			},
			{
				Role:    "user",
				Content: "Who are you?",
			},
		},
	}
	jsonData, err := json.Marshal(requestBody)
	if err != nil {
		log.Fatal(err)
	}
	// The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
	req, err := http.NewRequest("POST", "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions", bytes.NewBuffer(jsonData))
	if err != nil {
		log.Fatal(err)
	}
	// If the environment variable is not configured, replace with: apiKey := "sk-xxx"
	apiKey := os.Getenv("DASHSCOPE_API_KEY")
	req.Header.Set("Authorization", "Bearer "+apiKey)
	req.Header.Set("Content-Type", "application/json")
	// Send the request
	resp, err := client.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()
	// Read the response body
	bodyText, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	// Print the response
	fmt.Printf("%s\n", bodyText)
}

PHP

<?php
// The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
$url = 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions';
// If the environment variable is not configured, replace with: $apiKey = "sk-xxx"
$apiKey = getenv('DASHSCOPE_API_KEY');
// Set request headers
$headers = [
    'Authorization: Bearer '.$apiKey,
    'Content-Type: application/json'
];
// Set request body
$data = [
    // Model list: https://help.aliyun.com/model-studio/getting-started/models
    "model" => "qwen-plus",
    "messages" => [
        [
            "role" => "system",
            "content" => "You are a helpful assistant."
        ],
        [
            "role" => "user",
            "content" => "Who are you?"
        ]
    ]
];
// Initialize a cURL session
$ch = curl_init();
// Set cURL options
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
// Execute the cURL session
$response = curl_exec($ch);
// Check for errors
if (curl_errno($ch)) {
    echo 'Curl error: ' . curl_error($ch);
}
// Close the cURL resource
curl_close($ch);
// Output the response
echo $response;
?>

C#

using System.Net.Http.Headers;
using System.Text;

class Program
{
    private static readonly HttpClient httpClient = new HttpClient();

    static async Task Main(string[] args)
    {
        // If the environment variable is not configured, replace with: string? apiKey = "sk-xxx"
        // Singapore and China (Beijing) API keys differ. Get your API key: https://help.aliyun.com/model-studio/get-api-key
        string? apiKey = Environment.GetEnvironmentVariable("DASHSCOPE_API_KEY");

        if (string.IsNullOrEmpty(apiKey))
        {
            Console.WriteLine("API Key not set. Make sure the 'DASHSCOPE_API_KEY' environment variable is set.");
            return;
        }
        // The following base URL is for the China (Beijing) region. URLs vary by region. Replace {WorkspaceId} with your workspace ID.
        string url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/chat/completions";
        // Model list: https://help.aliyun.com/model-studio/getting-started/models
        string jsonContent = @"{
            ""model"": ""qwen-plus"",
            ""messages"": [
                {
                    ""role"": ""system"",
                    ""content"": ""You are a helpful assistant.""
                },
                {
                    ""role"": ""user"", 
                    ""content"": ""Who are you?""
                }
            ]
        }";

        // Send the request and get the response
        string result = await SendPostRequestAsync(url, jsonContent, apiKey);

        // Output the result
        Console.WriteLine(result);
    }

    private static async Task<string> SendPostRequestAsync(string url, string jsonContent, string apiKey)
    {
        using (var content = new StringContent(jsonContent, Encoding.UTF8, "application/json"))
        {
            // Set request headers
            httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
            httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

            // Send the request and get the response
            HttpResponseMessage response = await httpClient.PostAsync(url, content);

            // Handle the response
            if (response.IsSuccessStatusCode)
            {
                return await response.Content.ReadAsStringAsync();
            }
            else
            {
                return $"Request failed: {response.StatusCode}";
            }
        }
    }
}

API reference

For the input and output parameters, see Qwen API reference.
For other models, see Model list.

FAQ

How do I buy tokens after my Free quota runs out?

A: Go to Expenses and Costs. Ensure there are no overdue payments before calling Qwen models.

Calls to Qwen models are billed automatically. Bills are generated by the minute, with each entry detailing the charges for that minute. View usage details in Bill details.

How do I fix the `Model.AccessDenied` error after calling the model API?

A: This error occurs because you are using an API key from a sub-workspace. A sub-workspace cannot access applications or models in the root account workspace. To use a sub-workspace API key, the root account administrator must grant model authorization for the corresponding sub-workspace (for example, this topic uses the Qwen-Plus model). For detailed steps, see Configure model calling permissions.

How do I integrate with Chatbox, Cherry Studio, Cline, or Dify?

A: Follow the steps below based on your use case.

We use the most commonly used tools as examples. Steps for other tools are similar.

Chatbox

See Chatbox.

Cherry Studio

Click the Settings button in the lower-left corner. In the Model Service section, find Alibaba Cloud Model Studio. Enter your API key in API key. To obtain your API key, see Get an API Key. Enter https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/ in API endpoint (replace {WorkspaceId} with your workspace ID). Click Add.
In Model ID, enter the Qwen model you want to use. For example, use qwen-max-latest. For more models, see the Qwen models in the Model list. Model Name and Group name are generated automatically.
Select the added model at the top of the interface. Some models support web search. Turn on the web search toggle next to the input box. Test it by entering “What’s the weather like in Hangzhou?”:

Cline

See Cline.

Dify

See Dify.

Next steps

Explore more models	The example code uses `qwen-plus`. Model Studio also supports other Qwen models and third-party models such as DeepSeek and Llama. See the Model list for supported models and their API references.
Learn advanced features	The example code covers basic Q&A only. To learn more about the Qwen API, such as streaming output, structured output, and function calling, see the Text generation model overview.
Try models in the browser	If you want to interact with models through a dialog box, like on the Qwen official website, go to the Playground (China (Beijing) or Singapore). The Qwen official website integrates the Qwen API with tools such as web search and webpage parsing. Results may differ slightly from direct API calls.
Fine-tune models without code	Fine-tuning usually requires AI expertise. Model Studio provides no-code fine-tuning—you only need to provide a dataset. For details, see Model tuning in the console.

Account setup

Set your API key as an environment variable

Linux

Permanent environment variable

Temporary environment variable

macOS

Permanent environment variable

Zsh

Bash

Temporary environment variable

Windows

System Properties

CMD

Permanent environment variable

Temporary environment variable

PowerShell

Permanent environment variable

Temporary environment variable

Choose a development language

Python

Step 1: Set up Python

Check your Python version

FAQ

Windows

Linux and macOS

Set up a virtual environment (optional)

Install the OpenAI Python SDK or DashScope Python SDK

Install the OpenAI Python SDK

Install the DashScope Python SDK

Step 2: Call the API

OpenAI Python SDK

DashScope Python SDK

Node.js

Step 1: Set up your Node.js environment

Check your Node.js installation

Install the model calling SDK

Step 2: Call the model API

Java

Step 1: Set up your Java environment

Check your Java version

Install the model calling SDK

XML

Gradle

Step 2: Call the API

curl

OpenAI-compatible HTTP

DashScope HTTP

Other languages

API reference

FAQ

How do I buy tokens after my Free quota runs out?

How do I fix the Model.AccessDenied error after calling the model API?

How do I integrate with Chatbox, Cherry Studio, Cline, or Dify?

Chatbox

Cherry Studio

Cline

Dify

Next steps

How do I fix the `Model.AccessDenied` error after calling the model API?