Non-real-time speech recognition

Learn about non-real-time speech recognition features, audio file calls, and ways to improve recognition results.

Features

Non-real-time speech recognition converts recorded audio and video files into text for meeting transcription, call analysis, and subtitles. Short audio can return results in one request; longer recordings can be processed as asynchronous tasks.

• Languages and dialects: Automatically detect languages and recognize multiple languages and Chinese dialects. For coverage, see Speech recognition overview.
• Accuracy: Use hotwords for names, brands, and specialist terms, or provide context from previous conversation turns.
• Text processing: Polish spoken text, preserve dialect expressions, and filter sensitive words.
• Speaker diarization: Label speakers in transcripts to organize meetings and interviews.
• Structured results: Obtain sentences, words, and timestamps for subtitles, keyword highlighting, and audio navigation.
• Audio input: Use supported audio and video formats, sample rates, and channels.
• Long recordings: Asynchronously transcribe a single audio or video file of up to 12 hours and 2 GB.

Get started

Get an API key in the console and set the DASHSCOPE_API_KEY environment variable.

The examples use a publicly accessible, English, 16 kHz, mono WAV audio sample.

curl \
  "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/aigc/multimodal-generation/generation" \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-DashScope-SSE: disable" \
  -d '{
  "model": "qwen-audio-3.1-asr-flash",
  "input": {
    "messages": [
      {
        "role": "user",
        "content": [
          {
            "type": "input_audio",
            "input_audio": {
              "data": "https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav"
            }
          }
        ]
      }
    ]
  },
  "parameters": {
    "format": "wav",
    "sample_rate": "16000"
  }
}'

import json
import os
from urllib.request import Request, urlopen

api_url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"
body = {
    "model": "qwen-audio-3.1-asr-flash",
    "input": {
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_audio",
                        "input_audio": {
                            "data": "https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav"
                        }
                    }
                ]
            }
        ]
    },
    "parameters": {
        "format": "wav",
        "sample_rate": "16000"
    }
}
request = Request(
    api_url + "/services/aigc/multimodal-generation/generation",
    data=json.dumps(body).encode(),
    headers={
        "Authorization": "Bearer " + os.environ["DASHSCOPE_API_KEY"],
        "Content-Type": "application/json",
    },
)
with urlopen(request) as response:
    result = json.load(response)
print(result["output"]["text"])

curl \
  "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.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": "qwen-audio-3.1-asr-flash-filetrans",
  "input": {
    "file_urls": [
      "https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav"
    ]
  },
  "parameters": {}
}'

curl \
  "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/tasks/{task_id}" \
  -H "Authorization: Bearer $DASHSCOPE_API_KEY"

curl "{transcription_url}" -o transcription.json

import json
import os
import time
from urllib.request import Request, urlopen

api_url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"
headers = {
    "Authorization": "Bearer " + os.environ["DASHSCOPE_API_KEY"],
    "Content-Type": "application/json",
}
body = {
    "model": "qwen-audio-3.1-asr-flash-filetrans",
    "input": {"file_urls": ["https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav"]},
    "parameters": {},
}
request = Request(
    api_url + "/services/audio/asr/transcription",
    data=json.dumps(body).encode(),
    headers={**headers, "X-DashScope-Async": "enable"},
)
with urlopen(request) as response:
    task_id = json.load(response)["output"]["task_id"]

while True:
    query = Request(api_url + "/tasks/" + task_id, headers=headers)
    with urlopen(query) as response:
        result = json.load(response)
    status = result["output"]["task_status"]
    if status == "SUCCEEDED":
        break
    if status in ("FAILED", "CANCELED"):
        raise RuntimeError(json.dumps(result, ensure_ascii=False))
    time.sleep(3)

for item in result["output"]["results"]:
    if item["subtask_status"] != "SUCCEEDED":
        raise RuntimeError(json.dumps(item, ensure_ascii=False))
    with urlopen(item["transcription_url"]) as response:
        transcript = json.load(response)
    print(json.dumps(transcript, ensure_ascii=False, indent=2))

{
  "file_url": "https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav",
  "properties": {
    "audio_format": "pcm_s16le",
    "channels": [
      0
    ],
    "original_sampling_rate": 16000,
    "original_duration_in_milliseconds": 3782
  },
  "transcripts": [
    {
      "channel_id": 0,
      "content_duration_in_milliseconds": 3640,
      "text": "Please send the quarterly project report to Kellera before Friday. ",
      "sentences": [
        {
          "begin_time": 120,
          "end_time": 3760,
          "text": "Please send the quarterly project report to Kellera before Friday. ",
          "sentence_id": 1,
          "words": [
            {
              "begin_time": 120,
              "end_time": 320,
              "text": "Please",
              "punctuation": "",
              "confidence": 1.0
            },
            {
              "begin_time": 320,
              "end_time": 560,
              "text": " send",
              "punctuation": "",
              "confidence": 1.0
            }
          ]
        }
      ]
    }
  ],
  "usage": {
    "input_tokens": 47,
    "output_tokens": 12,
    "total_Tokens": 59
  }
}

Handle recognition results

• Synchronous recognition: In Qwen-Audio-ASR, output.text contains the complete accumulated text, and output.sentence contains details for the current sentence. Read output.text to save the full transcript.

• Asynchronous transcription: After the task succeeds, download the result file. Read transcripts[].text for each channel's full transcript, or transcripts[].sentences and its words for subtitles and audio navigation.

• Timestamps: Sentence and word begin_time and end_time values are positions in the audio, in milliseconds. The task query's end_time is the date and time when the task completed.

  NoteTimestamps are always enabled and cannot be disabled for Qwen-Audio-ASR, Qwen-Audio-ASR-Filetrans, Fun-ASR, Fun-ASR-Flash, and Paraformer. Asynchronous Qwen3-ASR-Filetrans calls also always return timestamps. For these calls, enable_words selects sentence- or word-level timestamps rather than disabling timestamps.

Improve recognition results

Adjust text readability, recognition of specific terms, speaker labels, and how results are returned to meet your needs.

Streaming output

Streaming output returns recognition results in SSE events after a complete audio file is submitted, so that you can show transcription progress before recognition finishes.

qwen-audio-3.1-asr-flash, Fun-ASR-Flash, and Qwen3-ASR-Flash support streaming output. Asynchronous transcription models, including Qwen-Audio-ASR-Filetrans, Fun-ASR, Qwen3-ASR-Filetrans, and Paraformer, provide result files after completion and do not support SSE recognition output.

Hotwords and context enhancement

Use hotwords to specify the spelling of names, product names, or technical terms that may be confused with similar-sounding words. Use context enhancement to provide previous conversation turns, business background, or related vocabulary. For model support, configuration, and examples, see Improve recognition accuracy.

Text polishing and dialect expressions

qwen-audio-3.1-asr-flash supports native text polishing to improve readability by organizing filler words, repetitions, and self-corrections.

qwen-audio-3.1-asr-flash and qwen-audio-3.1-asr-flash-filetrans transcribe Chinese dialects into Mandarin text by default. Set keep_dialect: true to preserve expressions specific to the dialect.

Speaker diarization

Enable speaker diarization to distinguish speakers in a meeting or interview. The speaker_id in recognition results identifies different speakers.

Sensitive-word filtering

Use sensitive-word filtering to mask or remove specified words in transcripts. Qwen-Audio-ASR-Filetrans, Fun-ASR, and Paraformer support special_word_filter to configure replacement lists, removal lists, and the built-in word list.

Use in production

Batch transcription requires audio storage, control of submission and query rates, completion notifications, and result persistence. For input preparation, callbacks, throttling, and retries, see Speech recognition best practices.

Supported models and regions

Usage limits

Choose an input method, audio format, and sample rate supported by the model. Parameters such as format and sample_rate must match the actual file.

Use mono audio for speaker diarization. The Paraformer model paraformer-8k-v2 supports only 8 kHz. Local files for Qwen3-ASR-Flash must be encoded or uploaded by the client; a local path cannot be used directly as an HTTP audio URL.

API reference

• Non-real-time speech recognition: Qwen-Audio-ASR API reference
• Non-real-time speech recognition: Qwen-Audio-ASR-Filetrans API reference
• Non-real-time speech recognition: Fun-ASR API reference
• Non-real-time speech recognition: Fun-ASR-Flash API reference
• Non-real-time speech recognition: Qwen3-ASR API reference
• Non-real-time speech recognition: Paraformer API reference

Model application listing and filing

For more information, see Application compliance filing.