Audio file transcription

​

Core features

• Multilingual recognition: Recognizes Chinese (including multiple dialects), English, Japanese, Korean, German, French, Russian, and 30+ other languages.
• Format compatibility: Accepts any sample rate and supports major audio and video formats, including AAC, WAV, and MP3.
• Long audio file processing: Handles asynchronous transcription for a single audio file up to 12 hours long and 2 GB in size. If speaker diarization is enabled, audio longer than 2 hours is not recommended.
• Singing voice recognition: Transcribes entire songs, even with background music (BGM). Only the fun-asr and fun-asr-2025-11-07 models support this feature.
• Recognition features: Configurable features include speaker diarization, sensitive word filtering, sentence-level and word-level timestamps, and hotword enhancement.

​

Supported models

• Qwen-Audio-3.1-ASR-Flash-Filetrans: qwen-audio-3.1-asr-flash-filetrans
• Qwen-Audio-3.0-ASR-Flash-Filetrans: qwen-audio-3.0-asr-flash-filetrans
• Qwen-Audio-3.1-ASR-Flash: qwen-audio-3.1-asr-flash
• Qwen-Audio-3.0-ASR-Flash: qwen-audio-3.0-asr-flash
• Fun-ASR: fun-asr (stable, currently equivalent to fun-asr-2025-11-07), fun-asr-2025-11-07 (snapshot), fun-asr-2025-08-25 (snapshot), fun-asr-mtl (stable, currently equivalent to fun-asr-mtl-2025-08-25, fun-asr is recommended), fun-asr-mtl-2025-08-25 (snapshot)
• Fun-ASR-Flash: fun-asr-flash-2026-06-15 (snapshot)
• Qwen3-ASR-Flash-Filetrans: qwen3-asr-flash-filetrans (stable, currently equivalent to qwen3-asr-flash-filetrans-2025-11-17), qwen3-asr-flash-filetrans-2025-11-17 (snapshot)
• Qwen3-ASR-Flash: qwen3-asr-flash (stable, currently equivalent to qwen3-asr-flash-2025-09-08), qwen3-asr-flash-2026-02-10 (latest snapshot), qwen3-asr-flash-2025-09-08 (snapshot)

​

Prerequisites

• Get an API key and set it as an environment variable.
• To call the API through the DashScope SDK, install the latest SDK.

​

Getting started

from http import HTTPStatus
from dashscope.audio.asr import Transcription
from urllib import request
import dashscope
import os
import json

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

# If you have not configured an environment variable, replace the following line with your API key: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

task_response = Transcription.async_call(
  model='qwen-audio-3.1-asr-flash-filetrans',
  file_urls=['https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/bjgrbu/hello_world_female_en.wav',
      'https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/rlrbee/hello_world_male_en.wav'],
  language_hints=['zh', 'en']  # language_hints is an optional parameter that specifies the language code of the audio to be recognized. For the value range, see the API reference.
)

transcription_response = Transcription.wait(task=task_response.output.task_id)

if transcription_response.status_code == HTTPStatus.OK:
  for transcription in transcription_response.output['results']:
    if transcription['subtask_status'] == 'SUCCEEDED':
      url = transcription['transcription_url']
      result = json.loads(request.urlopen(url).read().decode('utf8'))
      print(json.dumps(result, indent=4,
      ensure_ascii=False))
    else:
      print('transcription failed!')
      print(transcription)
else:
  print('Error: ', transcription_response.output.message)

{
  "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/bjgrbu/hello_world_female_en.wav",
  "properties": {
    "audio_format": "pcm_s16le",
    "channels": [
      0
    ],
    "original_sampling_rate": 24000,
    "original_duration_in_milliseconds": 3280
  },
  "transcripts": [
    {
      "channel_id": 0,
      "content_duration_in_milliseconds": 3000,
      "text": "Hello world, this is Alibaba Speech Lab. ",
      "sentences": [
        {
          "begin_time": 240,
          "end_time": 3240,
          "text": "Hello world, this is Alibaba Speech Lab. ",
          "sentence_id": 1,
          "words": [
            {
              "begin_time": 240,
              "end_time": 640,
              "text": "Hello",
              "punctuation": ""
            },
            {
              "begin_time": 640,
              "end_time": 960,
              "text": " world",
              "punctuation": ","
            },
            {
              "begin_time": 1280,
              "end_time": 1480,
              "text": " this",
              "punctuation": ""
            },
            {
              "begin_time": 1480,
              "end_time": 1840,
              "text": " is",
              "punctuation": ""
            },
            {
              "begin_time": 1840,
              "end_time": 2520,
              "text": " Alibaba",
              "punctuation": ""
            },
            {
              "begin_time": 2520,
              "end_time": 2920,
              "text": " Speech",
              "punctuation": ""
            },
            {
              "begin_time": 2920,
              "end_time": 3240,
              "text": " Lab",
              "punctuation": ". "
            }
          ]
        }
      ]
    }
  ]
}

{
  "file_url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/rlrbee/hello_world_male_en.wav",
  "properties": {
    "audio_format": "pcm_s16le",
    "channels": [
      0
    ],
    "original_sampling_rate": 24000,
    "original_duration_in_milliseconds": 4000
  },
  "transcripts": [
    {
      "channel_id": 0,
      "content_duration_in_milliseconds": 3160,
      "text": "Hello world, this is Alibaba Speech Lab. ",
      "sentences": [
        {
          "begin_time": 800,
          "end_time": 3960,
          "text": "Hello world, this is Alibaba Speech Lab. ",
          "sentence_id": 1,
          "words": [
            {
              "begin_time": 800,
              "end_time": 1200,
              "text": "Hello",
              "punctuation": ""
            },
            {
              "begin_time": 1200,
              "end_time": 1640,
              "text": " world",
              "punctuation": ","
            },
            {
              "begin_time": 1880,
              "end_time": 2120,
              "text": " this",
              "punctuation": ""
            },
            {
              "begin_time": 2120,
              "end_time": 2560,
              "text": " is",
              "punctuation": ""
            },
            {
              "begin_time": 2560,
              "end_time": 3360,
              "text": " Alibaba",
              "punctuation": ""
            },
            {
              "begin_time": 3360,
              "end_time": 3720,
              "text": " Speech",
              "punctuation": ""
            },
            {
              "begin_time": 3720,
              "end_time": 3960,
              "text": " Lab",
              "punctuation": ". "
            }
          ]
        }
      ]
    }
  ]
}

from http import HTTPStatus
from dashscope.audio.asr import Transcription
import dashscope
import os
import json

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

# If you have not configured an environment variable, replace the following line with your API key: dashscope.api_key = "sk-xxx"
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

transcribe_response = Transcription.async_call(
  model='qwen-audio-3.1-asr-flash-filetrans',
  file_urls=['https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/bjgrbu/hello_world_female_en.wav',
      'https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/rlrbee/hello_world_male_en.wav']
)

while True:
  if transcribe_response.output.task_status == 'SUCCEEDED' or transcribe_response.output.task_status == 'FAILED':
    break
  transcribe_response = Transcription.fetch(task=transcribe_response.output.task_id)

if transcribe_response.status_code == HTTPStatus.OK:
  print(json.dumps(transcribe_response.output, indent=4, ensure_ascii=False))
  print('transcription done!')

import requests
import json
import os
import time

# If you have not configured environment variables, replace the following line with your API key: api_key = "sk-xxx"
api_key = os.getenv("DASHSCOPE_API_KEY")
file_urls = [
  "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/bjgrbu/hello_world_female_en.wav",
  "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20260401/rlrbee/hello_world_male_en.wav",
]

region = "maas.qwencloudapi.com"

# Submit a file transcription task, including a list of file URLs to be transcribed
def submit_task(apikey, file_urls) -> str:

  headers = {
    "Authorization": f"Bearer {apikey}",
    "Content-Type": "application/json",
    "X-DashScope-Async": "enable",
  }
  data = {
    "model": "qwen-audio-3.1-asr-flash-filetrans",
    "input": {"file_urls": file_urls},
    "parameters": {
      "channel_id": [0],
      # "vocabulary_id": "vocab-Xxxx", # Optional, hotword ID.
    },
  }
  # URL of the audio file transcription service
  service_url = (
    f"https://{region}/api/v1/services/audio/asr/transcription"
  )
  response = requests.post(
    service_url, headers=headers, data=json.dumps(data)
  )

  # Print the response content
  if response.status_code == 200:
    return response.json()["output"]["task_id"]
  else:
    print("task failed!")
    print(response.json())
    return None


# Recursively query the task status until it is successful
def wait_for_complete(task_id):
  headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
    "X-DashScope-Async": "enable",
  }

  pending = True
  while pending:
    # URL of the task status query service
    service_url = f"https://{region}/api/v1/tasks/{task_id}"
    response = requests.post(
      service_url, headers=headers
    )
    if response.status_code == 200:
      status = response.json()['output']['task_status']
      if status == 'SUCCEEDED':
        print("task succeeded!")
        pending = False
        return response.json()['output']['results']
      elif status == 'RUNNING' or status == 'PENDING':
        pass
      else:
        print("task failed!")
        pending = False
    else:
      print("query failed!")
      pending = False
    print(response.json())
    time.sleep(0.1)


task_id = submit_task(apikey=api_key, file_urls=file_urls)
print("task_id: ", task_id)
result = wait_for_complete(task_id)
print("transcription result: ", result)

curl --location --request POST 'https://maas.qwencloudapi.com/api/v1/services/aigc/multimodal-generation/generation' \
  --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
  --header "Content-Type: application/json" \
  --header "X-DashScope-SSE: disable" \
  --data '{
  "model": "qwen-audio-3.1-asr-flash",
  "input": {
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "input_audio",
            "input_audio": {
              "data": "{YOUR_AUDIO_URL}"
            }
          }
        ]
      }
    ]
  },
  "parameters": {
    "format": "wav",
    "sample_rate": "16000"
  }
}'

{
  "output": {
    "output": {
      "sentence": {
        "text": "Hello World, this is Alibaba Speech Lab."
      }
    },
    "text": "Hello World, this is Alibaba Speech Lab."
  },
  "request_id": "..."
}

curl -X POST 'https://maas.qwencloudapi.com/api/v1/services/audio/asr/transcription' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-Async: enable" \
-d '{
  "model": "qwen3-asr-flash-filetrans",
  "input": {
    "file_url": "{YOUR_AUDIO_URL}"
  },
  "parameters": {
    "channel_id":[
      0
    ],
    "enable_itn": false,
    "enable_words": true
  }
}'

curl -X GET 'https://maas.qwencloudapi.com/api/v1/tasks/{task_id}' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json"

import com.google.gson.Gson;
import com.google.gson.annotations.SerializedName;
import okhttp3.*;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class Main {
  private static final String API_URL_SUBMIT = "https://maas.qwencloudapi.com/api/v1/services/audio/asr/transcription";
  private static final String API_URL_QUERY = "https://maas.qwencloudapi.com/api/v1/tasks/";
  private static final Gson gson = new Gson();

  public static void main(String[] args) {
    // If you have not configured environment variables, replace the following line with: String apiKey = "sk-xxx"
    String apiKey = System.getenv("DASHSCOPE_API_KEY");

    OkHttpClient client = new OkHttpClient();

    // 1. Submit task
    String payloadJson = """
        {
          "model": "qwen3-asr-flash-filetrans",
          "input": {
            "file_url": "{YOUR_AUDIO_URL}"
          },
          "parameters": {
            "channel_id": [0],
            "enable_itn": false,
            "enable_words": true
          }
        }
        """;

    RequestBody body = RequestBody.create(payloadJson, MediaType.get("application/json; charset=utf-8"));
    Request submitRequest = new Request.Builder()
        .url(API_URL_SUBMIT)
        .addHeader("Authorization", "Bearer " + apiKey)
        .addHeader("Content-Type", "application/json")
        .addHeader("X-DashScope-Async", "enable")
        .post(body)
        .build();

    String taskId = null;

    try (Response response = client.newCall(submitRequest).execute()) {
      if (response.isSuccessful() && response.body() != null) {
        String respBody = response.body().string();
        ApiResponse apiResp = gson.fromJson(respBody, ApiResponse.class);
        if (apiResp.output != null) {
          taskId = apiResp.output.taskId;
          System.out.println("Task submitted. task_id: " + taskId);
        } else {
          System.out.println("Submission response content: " + respBody);
          return;
        }
      } else {
        System.out.println("Task submission failed! HTTP code: " + response.code());
        if (response.body() != null) {
          System.out.println(response.body().string());
        }
        return;
      }
    } catch (IOException e) {
      e.printStackTrace();
      return;
    }

    // 2. Poll task status
    boolean finished = false;
    while (!finished) {
      try {
        TimeUnit.SECONDS.sleep(2);  // Wait for 2 seconds before querying again
      } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return;
      }

      String queryUrl = API_URL_QUERY + taskId;
      Request queryRequest = new Request.Builder()
          .url(queryUrl)
          .addHeader("Authorization", "Bearer " + apiKey)
          .addHeader("Content-Type", "application/json")
          .get()
          .build();

      try (Response response = client.newCall(queryRequest).execute()) {
        if (response.body() != null) {
          String queryResponse = response.body().string();
          ApiResponse apiResp = gson.fromJson(queryResponse, ApiResponse.class);

          if (apiResp.output != null && apiResp.output.taskStatus != null) {
            String status = apiResp.output.taskStatus;
            System.out.println("Current task status: " + status);
            if ("SUCCEEDED".equalsIgnoreCase(status)
                || "FAILED".equalsIgnoreCase(status)
                || "UNKNOWN".equalsIgnoreCase(status)) {
              finished = true;
              System.out.println("Task completed. Final result: ");
              System.out.println(queryResponse);
            }
          } else {
            System.out.println("Query response content: " + queryResponse);
          }
        }
      } catch (IOException e) {
        e.printStackTrace();
        return;
      }
    }
  }

  static class ApiResponse {
    @SerializedName("request_id")
    String requestId;
    Output output;
  }

  static class Output {
    @SerializedName("task_id")
    String taskId;
    @SerializedName("task_status")
    String taskStatus;
  }
}

import com.alibaba.dashscope.audio.qwen_asr.*;
import com.alibaba.dashscope.utils.Constants;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;

public class Main {
  public static void main(String[] args) {
    Constants.baseHttpApiUrl = "https://maas.qwencloudapi.com/api/v1";
    QwenTranscriptionParam param =
        QwenTranscriptionParam.builder()
            // If you have not configured environment variables, replace the following line with: .apiKey("sk-xxx")
            .apiKey(System.getenv("DASHSCOPE_API_KEY"))
            .model("qwen3-asr-flash-filetrans")
            .fileUrl("{YOUR_AUDIO_URL}")
            //.parameter("language", "zh")
            //.parameter("channel_id", new ArrayList<String>(){{add("0");add("1");}})
            .parameter("enable_itn", false)
            .parameter("enable_words", true)
            .build();
    try {
      QwenTranscription transcription = new QwenTranscription();
      // Submit the task
      QwenTranscriptionResult result = transcription.asyncCall(param);
      System.out.println("create task result: " + result);
      // Query the task status
      result = transcription.fetch(QwenTranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
      System.out.println("task status: " + result);
      // Wait for the task to complete
      result =
          transcription.wait(
              QwenTranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
      System.out.println("task result: " + result);
      // Get the speech recognition result
      QwenTranscriptionTaskResult taskResult = result.getResult();
      if (taskResult != null) {
        // Get the URL of the recognition result
        String transcriptionUrl = taskResult.getTranscriptionUrl();
        // Get the result from the URL
        HttpURLConnection connection =
            (HttpURLConnection) new URL(transcriptionUrl).openConnection();
        connection.setRequestMethod("GET");
        connection.connect();
        BufferedReader reader =
            new BufferedReader(new InputStreamReader(connection.getInputStream()));
        // Format and print the JSON result
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        System.out.println(gson.toJson(gson.fromJson(reader, JsonObject.class)));
      }
    } catch (Exception e) {
      System.out.println("error: " + e);
    }
  }
}

import json
import os
import sys
from http import HTTPStatus

import dashscope
from dashscope.audio.qwen_asr import QwenTranscription
from dashscope.api_entities.dashscope_response import TranscriptionResponse


# run the transcription script
if __name__ == '__main__':
  # If you have not configured environment variables, replace the following line with: dashscope.api_key = "sk-xxx"
  dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

  dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'
  task_response = QwenTranscription.async_call(
    model='qwen3-asr-flash-filetrans',
    file_url='{YOUR_AUDIO_URL}',
    #language="",
    enable_itn=False,
    enable_words=True
  )
  print(f'task_response: {task_response}')
  print(task_response.output.task_id)
  query_response = QwenTranscription.fetch(task=task_response.output.task_id)
  print(f'query_response: {query_response}')
  task_result = QwenTranscription.wait(task=task_response.output.task_id)
  print(f'task_result: {task_result}')

import os
import dashscope

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

messages = [
  {"role": "user", "content": [{"audio": "{YOUR_AUDIO_URL}"}]}
]

response = dashscope.MultiModalConversation.call(
  # If you have not configured environment variables, replace the following line with: api_key = "sk-xxx"
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  model="qwen3-asr-flash",
  messages=messages,
  result_format="message",
  asr_options={
    #"language": "zh", # Optional. If the audio language is known, you can specify it using this parameter to improve recognition accuracy.
    "enable_itn":False
  }
)
print(response)

import base64, pathlib

# {YOUR_AUDIO_FILE} is the local audio file to transcribe. Replace it with the path to your own audio file and make sure it meets the audio requirements.
file_path = pathlib.Path("{YOUR_AUDIO_FILE}")
base64_str = base64.b64encode(file_path.read_bytes()).decode()
data_uri = f"data:audio/mpeg;base64,{base64_str}"

import base64
import dashscope
import os
import pathlib

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

# Replace with your actual audio file path
file_path = "{YOUR_AUDIO_FILE}"
# Replace with your actual audio file MIME type
audio_mime_type = "audio/mpeg"

file_path_obj = pathlib.Path(file_path)
if not file_path_obj.exists():
  raise FileNotFoundError(f"Audio file not found: {file_path}")

base64_str = base64.b64encode(file_path_obj.read_bytes()).decode()
data_uri = f"data:{audio_mime_type};base64,{base64_str}"

messages = [
  {"role": "user", "content": [{"audio": data_uri}]}
]
response = dashscope.MultiModalConversation.call(
  # If you have not configured environment variables, replace the following line with: api_key = "sk-xxx",
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  model="qwen3-asr-flash",
  messages=messages,
  result_format="message",
  asr_options={
    # "language": "zh", # Optional. If the audio language is known, you can specify it using this parameter to improve recognition accuracy.
    "enable_itn":False
  }
)
print(response)

import os
import dashscope

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

# Replace ABSOLUTE_PATH/{YOUR_AUDIO_FILE} with the absolute path to your local audio file
audio_file_path = "file://ABSOLUTE_PATH/{YOUR_AUDIO_FILE}"

messages = [
  {"role": "user", "content": [{"audio": audio_file_path}]}
]
response = dashscope.MultiModalConversation.call(
  # If you have not configured environment variables, replace the following line with: api_key = "sk-xxx"
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  model="qwen3-asr-flash",
  messages=messages,
  result_format="message",
  asr_options={
    # "language": "zh", # Optional. If the audio language is known, you can specify it using this parameter to improve recognition accuracy.
    "enable_itn":False
  }
)
print(response)

import os
import dashscope

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

messages = [
  {"role": "user", "content": [{"audio": "{YOUR_AUDIO_URL}"}]}
]
response = dashscope.MultiModalConversation.call(
  # If you have not configured environment variables, replace the following line with: api_key = "sk-xxx"
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  model="qwen3-asr-flash",
  messages=messages,
  result_format="message",
  asr_options={
    # "language": "zh", # Optional. If the audio language is known, you can specify it using this parameter to improve recognition accuracy.
    "enable_itn":False
  },
  stream=True
)

for response in response:
  try:
    print(response["output"]["choices"][0]["message"].content[0]["text"])
  except:
    pass

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversation;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationParam;
import com.alibaba.dashscope.aigc.multimodalconversation.MultiModalConversationResult;
import com.alibaba.dashscope.common.MultiModalMessage;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.UploadFileException;
import com.alibaba.dashscope.utils.Constants;
import io.reactivex.Flowable;

public class Main {
  public static void simpleMultiModalConversationCall()
      throws ApiException, NoApiKeyException, UploadFileException {
    MultiModalConversation conv = new MultiModalConversation();
    MultiModalMessage userMessage = MultiModalMessage.builder()
        .role(Role.USER.getValue())
        .content(Arrays.asList(
        Collections.singletonMap("audio", "{YOUR_AUDIO_URL}")))
        .build();

    MultiModalMessage sysMessage = MultiModalMessage.builder().role(Role.SYSTEM.getValue())
        .build();

    Map<String, Object> asrOptions = new HashMap<>();
    asrOptions.put("enable_itn", false);
    // asrOptions.put("language", "zh"); // Optional. If the audio language is known, you can specify it using this parameter to improve recognition accuracy.
    MultiModalConversationParam param = MultiModalConversationParam.builder()
        // If you have not configured environment variables, replace the following line with: .apiKey("sk-xxx")
        .apiKey(System.getenv("DASHSCOPE_API_KEY"))
        .model("qwen3-asr-flash")
        .message(sysMessage)
        .message(userMessage)
        .parameter("asr_options", asrOptions)
        .build();
    Flowable<MultiModalConversationResult> resultFlowable = conv.streamCall(param);
    resultFlowable.blockingForEach(item -> {
      try {
        System.out.println(item.getOutput().getChoices().get(0).getMessage().getContent().get(0).get("text"));
      } catch (Exception e){
        System.exit(0);
      }
    });
  }

  public static void main(String[] args) {
    try {
      Constants.baseHttpApiUrl = "https://maas.qwencloudapi.com/api/v1";
      simpleMultiModalConversationCall();
    } catch (ApiException | NoApiKeyException | UploadFileException e) {
      System.out.println(e.getMessage());
    }
    System.exit(0);
  }
}

curl -X POST "https://maas.qwencloudapi.com/api/v1/services/aigc/multimodal-generation/generation" \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-H "X-DashScope-SSE: enable" \
-d '{
  "model": "qwen3-asr-flash",
  "input": {
    "messages": [
      {
        "content": [
          {
            "text": ""
          }
        ],
        "role": "system"
      },
      {
        "content": [
          {
            "audio": "{YOUR_AUDIO_URL}"
          }
        ],
        "role": "user"
      }
    ]
  },
  "parameters": {
    "incremental_output": true,
    "asr_options": {
      "enable_itn": false
    }
  }
}'

from openai import OpenAI
import os

try:
  client = OpenAI(
    # If you have not configured environment variables, replace the following line with: api_key = "sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
  )


  stream_enabled = False  # Enable streaming output
  completion = client.chat.completions.create(
    model="qwen3-asr-flash",
    messages=[
      {
        "content": [
          {
            "type": "input_audio",
            "input_audio": {
              "data": "{YOUR_AUDIO_URL}"
            }
          }
        ],
        "role": "user"
      }
    ],
    stream=stream_enabled,
    # Do not set stream_options when stream is False
    # stream_options={"include_usage": True},
    extra_body={
      "asr_options": {
        # "language": "zh",
        "enable_itn": False
      }
    }
  )
  if stream_enabled:
    full_content = ""
    print("Streaming output:")
    for chunk in completion:
      # If stream_options.include_usage is True, the last chunk's choices field is an empty list and should be skipped (token usage can be obtained via chunk.usage)
      print(chunk)
      if chunk.choices and chunk.choices[0].delta.content:
        full_content += chunk.choices[0].delta.content
    print(f"Full content: {full_content}")
  else:
    print(f"Non-streaming output: {completion.choices[0].message.content}")
except Exception as e:
  print(f"Error: {e}")

// Preparation before running:
// Works on Windows/Mac/Linux:
// 1. Ensure Node.js is installed (version >= 14 recommended)
// 2. Run this command to install dependencies: npm install openai

import OpenAI from "openai";

const client = new OpenAI({
  // If you have not configured environment variables, replace the following line with: apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
});

async function main() {
  try {
    const streamEnabled = false; // Enable streaming output
    const completion = await client.chat.completions.create({
      model: "qwen3-asr-flash",
      messages: [
        {
          role: "user",
          content: [
            {
              type: "input_audio",
              input_audio: {
                data: "{YOUR_AUDIO_URL}"
              }
            }
          ]
        }
      ],
      stream: streamEnabled,
      // Do not set stream_options when stream is False
      // stream_options: {
      //   "include_usage": true
      // },
      asr_options: {
        // language: "zh",
        enable_itn: false
      }
    });

    if (streamEnabled) {
      let fullContent = "";
      console.log("Streaming output:");
      for await (const chunk of completion) {
        console.log(JSON.stringify(chunk));
        if (chunk.choices && chunk.choices.length > 0) {
          const delta = chunk.choices[0].delta;
          if (delta && delta.content) {
            fullContent += delta.content;
          }
        }
      }
      console.log(`Full content: ${fullContent}`);
    } else {
      console.log(`Non-streaming output: ${completion.choices[0].message.content}`);
    }
  } catch (err) {
    console.error(`Error: ${err}`);
  }
}

main();

curl -X POST 'https://maas.qwencloudapi.com/compatible-mode/v1/chat/completions' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json" \
-d '{
  "model": "qwen3-asr-flash",
  "messages": [
    {
      "content": [
        {
          "type": "input_audio",
          "input_audio": {
            "data": "{YOUR_AUDIO_URL}"
          }
        }
      ],
      "role": "user"
    }
  ],
  "stream":false,
  "asr_options": {
    "enable_itn": false
  }
}'

import base64, pathlib

# {YOUR_AUDIO_FILE} is the local audio file to transcribe. Replace it with the path to your own audio file and make sure it meets the audio requirements.
file_path = pathlib.Path("{YOUR_AUDIO_FILE}")
base64_str = base64.b64encode(file_path.read_bytes()).decode()
data_uri = f"data:audio/mpeg;base64,{base64_str}"

import base64
from openai import OpenAI
import os
import pathlib

try:
  # Replace with your actual audio file path
  file_path = "{YOUR_AUDIO_FILE}"
  # Replace with your actual audio file MIME type
  audio_mime_type = "audio/mpeg"

  file_path_obj = pathlib.Path(file_path)
  if not file_path_obj.exists():
    raise FileNotFoundError(f"Audio file not found: {file_path}")

  base64_str = base64.b64encode(file_path_obj.read_bytes()).decode()
  data_uri = f"data:{audio_mime_type};base64,{base64_str}"

  client = OpenAI(
    # If you have not configured environment variables, replace the following line with: api_key = "sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
  )


  stream_enabled = False  # Enable streaming output
  completion = client.chat.completions.create(
    model="qwen3-asr-flash",
    messages=[
      {
        "content": [
          {
            "type": "input_audio",
            "input_audio": {
              "data": data_uri
            }
          }
        ],
        "role": "user"
      }
    ],
    stream=stream_enabled,
    # Do not set stream_options when stream is False
    # stream_options={"include_usage": True},
    extra_body={
      "asr_options": {
        # "language": "zh",
        "enable_itn": False
      }
    }
  )
  if stream_enabled:
    full_content = ""
    print("Streaming output:")
    for chunk in completion:
      # If stream_options.include_usage is True, the last chunk's choices field is an empty list and should be skipped (token usage can be obtained via chunk.usage)
      print(chunk)
      if chunk.choices and chunk.choices[0].delta.content:
        full_content += chunk.choices[0].delta.content
    print(f"Full content: {full_content}")
  else:
    print(f"Non-streaming output: {completion.choices[0].message.content}")
except Exception as e:
  print(f"Error: {e}")

// Preparation before running:
// Works on Windows/Mac/Linux:
// 1. Ensure Node.js is installed (version >= 14 recommended)
// 2. Run this command to install dependencies: npm install openai

import OpenAI from "openai";
import { readFileSync } from 'fs';

const client = new OpenAI({
  // If you have not configured environment variables, replace the following line with: apiKey: "sk-xxx",
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
});

const encodeAudioFile = (audioFilePath) => {
    const audioFile = readFileSync(audioFilePath);
    return audioFile.toString('base64');
};

// Replace with your actual audio file path
const dataUri = `data:audio/mpeg;base64,${encodeAudioFile("{YOUR_AUDIO_FILE}")}`;

async function main() {
  try {
    const streamEnabled = false; // Enable streaming output
    const completion = await client.chat.completions.create({
      model: "qwen3-asr-flash",
      messages: [
        {
          role: "user",
          content: [
            {
              type: "input_audio",
              input_audio: {
                data: dataUri
              }
            }
          ]
        }
      ],
      stream: streamEnabled,
      // Do not set stream_options when stream is False
      // stream_options: {
      //   "include_usage": true
      // },
      asr_options: {
        // language: "zh",
        enable_itn: false
      }
    });

    if (streamEnabled) {
      let fullContent = "";
      console.log("Streaming output:");
      for await (const chunk of completion) {
        console.log(JSON.stringify(chunk));
        if (chunk.choices && chunk.choices.length > 0) {
          const delta = chunk.choices[0].delta;
          if (delta && delta.content) {
            fullContent += delta.content;
          }
        }
      }
      console.log(`Full content: ${fullContent}`);
    } else {
      console.log(`Non-streaming output: ${completion.choices[0].message.content}`);
    }
  } catch (err) {
    console.error(`Error: ${err}`);
  }
}

main();

import os
from openai import OpenAI

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)

completion = client.chat.completions.create(
  model="qwen3-omni-flash",
  messages=[
    {"role": "system", "content": "Transcribe the following audio exactly as spoken. Output only the transcription text. Ignore non-speech sounds."},
    {"role": "user", "content": [
      {"type": "input_audio", "input_audio": {"data": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250211/tixcef/cherry.wav"}},
      {"type": "text", "text": "Transcribe this audio."}
    ]}
  ],
  modalities=["text"],
  stream=True,
)

for chunk in completion:
  if chunk.choices and chunk.choices[0].delta.content:
    print(chunk.choices[0].delta.content, end="")

​

Context enhancement

• Hotword lists in various delimiter formats (for example: hotword1, hotword2, hotword3, hotword4)
• Free-form paragraphs or passages of any length
• Mixed content: any combination of word lists and paragraphs
• Irrelevant or meaningless text, including gibberish. The model tolerates irrelevant content well, and recognition quality rarely degrades because of it.

• A word list:
  • List 1:

Bulge Bracket, Boutique, Middle Market, domestic securities firms

• List 2:

Bulge Bracket Boutique Middle Market domestic securities firms

• List 3:

['Bulge Bracket', 'Boutique', 'Middle Market', 'domestic securities firms']

• Natural language:

Investment bank classification: a quick guide.
Recently a few friends in Australia asked me what investment banks really are. Here is a quick primer. For students studying abroad, investment banks fall into four broad categories: Bulge Bracket, Boutique, Middle Market, and domestic securities firms.
Bulge Bracket banks: the nine top investment banks we often refer to, including Goldman Sachs, Morgan Stanley, and so on. They are large in both business scope and scale.
Boutique banks: relatively small in size but highly focused in their service areas. Firms such as Lazard and Evercore have deep expertise in specific fields.
Middle Market banks: serve mid-sized companies with M&A, IPO, and similar services. Though smaller than the bulge brackets, they hold strong positions in specific markets.
Domestic securities firms: as the Chinese market has risen, domestic firms play an increasingly important role internationally.
There are also further breakdowns by position and business line you can find in related charts. Hopefully this helps you understand investment banks and prepare for your career.

• Natural language with distracting content: some text is unrelated to the audio, such as the names in the example below.

Investment bank classification: a quick guide.
Recently a few friends in Australia asked me what investment banks really are. Here is a quick primer. For students studying abroad, investment banks fall into four broad categories: Bulge Bracket, Boutique, Middle Market, and domestic securities firms.
Bulge Bracket banks: the nine top investment banks we often refer to, including Goldman Sachs, Morgan Stanley, and so on. They are large in both business scope and scale.
Boutique banks: relatively small in size but highly focused in their service areas. Firms such as Lazard and Evercore have deep expertise in specific fields.
Middle Market banks: serve mid-sized companies with M&A, IPO, and similar services. Though smaller than the bulge brackets, they hold strong positions in specific markets.
Domestic securities firms: as the Chinese market has risen, domestic firms play an increasingly important role internationally.
There are also further breakdowns by position and business line you can find in related charts. Hopefully this helps you understand investment banks and prepare for your career.
Wang Haoxuan, Li Zihan, Zhang Jingxing, Liu Xinyi, Chen Junjie, Yang Siyuan, Zhao Yutong, Huang Zhiqiang, Zhou Zimo, Wu Yajing, Xu Ruoxi, Sun Haoran, Hu Jinyu, Zhu Chenxi, Guo Wenbo, He Jingshu, Gao Yuhang, Lin Yifei,
Zheng Xiaoyan, Liang Bowen, Luo Jiaqi, Song Mingzhe, Xie Wanting, Tang Ziqian, Han Mengyao, Feng Yiran, Cao Qinxue, Deng Zirui, Xiao Wangshu, Xu Jiashu,
Cheng Yinuo, Yuan Zhiruo, Peng Haoyu, Dong Simiao, Fan Jingyu, Su Zijin, Lyu Wenxuan, Jiang Shihan, Ding Muchen,
Wei Shuyao, Ren Tianyou, Jiang Yichen, Hua Qingyu, Shen Xinghe, Fu Jinyu, Yao Xingchen, Zhong Lingyu, Yan Licheng, Jin Ruoshui, Tao Ranting, Qi Shaoshang, Xue Zhilan, Zou Yunfan, Xiong Ziang, Bai Wenfeng, Yi Qianfan

​

Advanced features

​

Long audio file processing

• Qwen-Audio-3.x-ASR-Flash-Filetrans/Fun-ASR/Qwen3-ASR-Flash-Filetrans: Each audio file must be no larger than 2 GB and no longer than 12 hours.
• Qwen-Audio-3.1-ASR-Flash: Each audio file must be no larger than 2 GB and no longer than 5 minutes.
• Qwen-Audio-3.x-ASR-Flash/Fun-ASR-Flash/Qwen3-ASR-Flash: Each audio file must be no larger than 10 MB and no longer than 5 minutes. For longer audio, use Qwen-Audio-3.1-ASR-Flash-Filetrans, Fun-ASR, or Qwen3-ASR-Flash-Filetrans.
• When speaker diarization is enabled: Audio longer than 2 hours is not recommended, because recognition may fail or time out. See Speaker diarization.

1. Submit the transcription task and get a task_id.
2. Poll for the task status, or use the SDK's wait method to block until the task finishes.
3. When the task completes, download the result JSON from the returned URL.

​

Speaker diarization

{
  "transcripts": [
    {
      "sentences": [
        { "begin_time": 100, "end_time": 3820, "text": "Hello, let's review the project progress today.", "speaker_id": 0 },
        { "begin_time": 3820, "end_time": 6500, "text": "Sure, I'll start with my update.", "speaker_id": 1 }
      ]
    }
  ]
}

​

Sensitive word filtering

• filter_with_signed.word_list: A string array of sensitive words to replace with an equal number of asterisks. For example, with ["test"], "Run a test for me" becomes "Run a **** for me".
• filter_with_empty.word_list: A string array of sensitive words to remove entirely from the result. For example, with ["start"], "Is the game about to start" becomes "Is the game about to".
• system_reserved_filter: A boolean that defaults to true. Specifies whether to also apply the built-in sensitive word list, which is combined with your custom lists.

{
  "special_word_filter": {
    "filter_with_signed": {
      "word_list": ["test"]
    },
    "filter_with_empty": {
      "word_list": ["start", "happen"]
    },
    "system_reserved_filter": true
  }
}

​

Emotion recognition

• OpenAI-compatible interface (Qwen3-ASR-Flash): choices[].delta.annotations[].emotion for streaming output, or choices[].message.annotations[].emotion for non-streaming output.
• DashScope synchronous interface (Qwen3-ASR-Flash): output.choices[].message.annotations[].emotion.
• DashScope asynchronous task interface (Qwen3-ASR-Flash-Filetrans): transcripts[].sentences[].emotion, alongside the timestamp fields in each sentence object.

{
  "transcripts": [{
    "sentences": [{
      "begin_time": 0,
      "end_time": 1440,
      "text": "Welcome to QwenCloud.",
      "emotion": "neutral",
      "language": "en"
    }]
  }]
}

​

Get timestamps

• Qwen-Audio-3.x-ASR-Flash-Filetrans/Qwen-Audio-3.x-ASR-Flash/Fun-ASR/Fun-ASR-Flash: Timestamps are always on and cannot be turned off.
• Qwen3-ASR-Flash-Filetrans: Timestamps are supported only through the DashScope asynchronous interface, where they are always on. Use the enable_words request parameter to control the granularity: false (default) returns sentence-level timestamps, and true returns word-level timestamps. Word-level timestamps are supported only for Chinese, English, Japanese, Korean, German, French, Spanish, Italian, Portuguese, and Russian. Accuracy is not guaranteed for other languages.

• Sentence level: sentences[].begin_time and sentences[].end_time mark the start and end of each sentence in the audio.
• Word level: The sentences[].words[] array, where each element contains begin_time, end_time, and text (the word).

{
  "transcripts": [{
    "sentences": [{
      "begin_time": 100,
      "end_time": 3820,
      "text": "Hello, let's review the project progress today.",
      "words": [
        { "begin_time": 100, "end_time": 596, "text": "Hello" },
        { "begin_time": 596, "end_time": 844, "text": "let's" }
      ]
    }]
  }]
}

​

Going live

• File hosting: Upload audio files to an object storage service such as OSS and call the API by URL. Avoid local file uploads, which are capped at 100 QPS and cannot be scaled up.
• Asynchronous polling: Long audio transcription is asynchronous, and the task query API is limited to 20 QPS by default. Set a reasonable polling interval, such as 2 to 5 seconds, to avoid triggering rate limits. For polling strategies and batch task management, see Asynchronous task management.
• Error handling: Implement a robust retry mechanism. For network timeouts or temporary server-side errors (5xx), retry with an exponential backoff strategy.
• Noise reduction: For noisy audio, preprocess it with a tool such as FFmpeg before you submit it for recognition.
• Model selection: Choose the model based on audio duration. For audio within 5 minutes, use Qwen3-ASR-Flash. For audio longer than 5 minutes, use Qwen-Audio-3.1-ASR-Flash-Filetrans, Fun-ASR, or Qwen3-ASR-Flash-Filetrans.

​

Compare models

​

API reference

​

FAQ

# Check container format (format_name), codec (codec_name), sample rate (sample_rate), and number of channels (channels)
ffprobe -v error -show_entries format=format_name -show_entries stream=codec_name,sample_rate,channels -of default=noprint_wrappers=1 your_audio_file.mp3

# -i: Input file
# -ss 00:01:30: Start time (1 minute 30 seconds)
# -t 00:02:00: Duration (2 minutes)
# -c copy: Copy audio stream without re-encoding (fast)
# output_clip.wav: Output file
ffmpeg -i long_audio.wav -ss 00:01:30 -t 00:02:00 -c copy output_clip.wav

# -i: Input file
# -ac 1: Set to 1 channel (mono)
# -ar 16000: Set sample rate to 16000 Hz (16 kHz)
# -sample_fmt s16: Set sample format to 16-bit signed integer PCM
# output.wav: Output file
ffmpeg -i input.mp3 -ac 1 -ar 16000 -sample_fmt s16 output.wav

messages=[
  {"role": "system", "content": "You are transcribing a medical consultation. Key terms: diabetes, hypertension, metformin."},
  {"role": "user", "content": [{"type": "input_audio", "input_audio": {"data": "..."}}, {"type": "text", "text": "Transcribe this audio."}]}
]