All Products
Search
Document Center

Alibaba Cloud Model Studio:Improve recognition accuracy

Last Updated:Nov 07, 2026

Improve recognition of names, product names, and industry terms with hotwords (instant or precompiled) and contextual biasing.

Choose an optimization method

Names, product names, and industry terms can sound like common words, resulting in homophones or incorrect spellings in transcripts. Hotwords and contextual biasing supply correct spellings or relevant background to help improve recognition.

Choose based on the information your application already has: use hotwords for a known list of terms, or contextual biasing for existing conversations or business descriptions. For hotwords, choose instant or precompiled lists depending on whether the same list needs to be reused across requests. Check Supported models and regions before use.

MethodWhen to useHow to use

Instant hotwords

Names and terms change with each request, or you have a few temporary terms and do not need to store a list.

Include a term-to-weight object in each recognition request. The application supplies the correct spellings and can adjust how strongly the model favors each term through its weight.

Precompiled hotwords

You have a business glossary or repeatedly recognize the same set of terms and want to maintain one shared list.

Create a list of terms, weights, and optional languages, then reference its ID during recognition. Update the list when the glossary changes instead of resubmitting all entries in every request.

Contextual biasing

Your application already stores recent conversations, business descriptions, or domain text that can help recognition.

Send the relevant text as context messages with the audio. You do not need to extract individual terms or assign weights. Include the correct spellings of target terms. A known term list can also be used as hotwords to address the same type of error.

Use hotwords

Before running the examples, download the sample audio and prepare an API key from the Model Studio console. Audio text: “Please send the quarterly project report to Kelyra before Friday.”

Instant hotwords

Instant hotwords suit terms that change with each request. Set parameters.vocabulary to a JSON object whose keys are hotword strings and whose values are integer weights. You do not need to create a list first.

  1. Recognize the audio without hotwords

    Without hotwords, the name in this sample is not recognized accurately. The following request returns the unconfigured recognition result.

    curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.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": "https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav"
                }
              }
            ]
          }
        ]
      },
      "parameters": {
        "format": "wav",
        "sample_rate": 16000
      }
    }
    '
    
  2. Add instant hotwords to the request

    Add “Kelyra” to the same request with a weight of 4. Keep the other inputs unchanged. For weight ranges and tuning, see Adjust hotword weights.

    curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.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": "https://g-adoc.alcasset.com/media/maas_docs/sfm-cn/en/audios/6a4b3c2d1e0f9092.wav"
                }
              }
            ]
          }
        ]
      },
      "parameters": {
        "format": "wav",
        "sample_rate": 16000,
        "vocabulary": {
          "Kelyra": 4
        }
      }
    }
    '
    

Compare the example transcripts before and after configuration:

ConfigurationExample transcript

Without configuration

Please send the quarterly project report to Kellira before Friday.

With configuration

Please send the quarterly project report to Kelyra before Friday.

Precompiled hotwords

Precompiled hotwords suit business vocabularies that need to be reused across requests. Create a list in advance, then pass vocabulary_id during recognition instead of sending all entries again.

Submit entries as a JSON array when creating a list. Each entry has the following fields:

FieldTypeRequiredDescription

text

string

Yes

An actual word in a language supported by the selected model. For length requirements, see Hotword text rules.

weight

integer

Yes

Use 1–5 for regular hotwords, starting at 4. Some models also support a super hotword weight of 50. See Adjust hotword weights.

lang

string

No

Language code that determines which language the entry applies to. Omit it if unknown. For its relationship with the recognition parameter language_hints, see Organize and maintain vocabularies.

The target model specified when creating the list must match the recognition model.

NoteHotword management and speech recognition must use the same account. Otherwise, recognition cannot access the vocabulary.

HTTP / cURL

  1. Create a hotword list

    This example uses qwen-audio-3.1-asr-flash and specifies the target model through target_model. Save output.vocabulary_id from the response.

    curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/audio/asr/customization' \
      --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
      --header "Content-Type: application/json" \
      --data @- <<EOF
    {
      "model": "speech-biasing",
      "input": {
        "action": "create_vocabulary",
        "target_model": "qwen-audio-3.1-asr-flash",
        "prefix": "testpfx",
        "vocabulary": [
          {
            "text": "Kelyra",
            "weight": 4,
            "lang": "en"
          }
        ]
      }
    }
    EOF
    
  2. Check that the list is ready

    Replace <vocabulary_id> with the ID returned by the create request, then query the list. Proceed with recognition when output.status is OK.

    export VOCABULARY_ID="<vocabulary_id>"
    
    curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/audio/asr/customization' \
      --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
      --header "Content-Type: application/json" \
      --data @- <<EOF
    {
      "model": "speech-biasing",
      "input": {
        "action": "query_vocabulary",
        "vocabulary_id": "$VOCABULARY_ID"
      }
    }
    EOF
    
  3. Reference the list during recognition

    Reference the list through parameters.vocabulary_id in the recognition request. You do not need to send its entries again.

    curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.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 @- <<EOF
    {
      "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,
        "vocabulary_id": "$VOCABULARY_ID"
      }
    }
    EOF
    
  4. Reuse or delete the list

    Later requests can continue using the same ID. Run the following delete request only when the list is no longer needed, to release its quota.

    curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/audio/asr/customization' \
      --header "Authorization: Bearer $DASHSCOPE_API_KEY" \
      --header "Content-Type: application/json" \
      --data @- <<EOF
    {
      "model": "speech-biasing",
      "input": {
        "action": "delete_vocabulary",
        "vocabulary_id": "$VOCABULARY_ID"
      }
    }
    EOF
    

SDK

NoteSDK examples require DashScope Python SDK 2.0.1 or later, or Java SDK 2.22.23 or later. See Install SDKs for installation.

The Java and Python examples use qwen-audio-3.1-asr-flash-streaming to create, query, use, and delete a list. Deletion in finally cleans up demonstration resources. Keep the list and its ID when you need to reuse it in production.

import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.utils.Constants;
import java.io.File;
import java.util.Arrays;
import com.alibaba.dashscope.audio.asr.vocabulary.Vocabulary;
import com.alibaba.dashscope.audio.asr.vocabulary.VocabularyService;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

public class Main {
    public static void main(String[] args) throws Exception {
        String apiKey = System.getenv("DASHSCOPE_API_KEY");
        Constants.baseHttpApiUrl = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1";
        Constants.baseWebsocketApiUrl = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference";
        String model = "qwen-audio-3.1-asr-flash-streaming";
        JsonArray words = new JsonArray();
        for (String text : Arrays.asList("Kelyra")) {
            JsonObject word = new JsonObject();
            word.addProperty("text", text);
            word.addProperty("weight", 4);
            words.add(word);
        }
        VocabularyService service = new VocabularyService(apiKey);
        // targetModel must match the model used for recognition.
        Vocabulary vocabulary = service.createVocabulary(model, "testpfx", words);
        try {
            if (!"OK".equals(service.queryVocabulary(vocabulary.getVocabularyId()).getStatus())) {
                throw new IllegalStateException("Vocabulary is not ready");
            }
            Recognition recognizer = new Recognition();
            try {
                RecognitionParam param = RecognitionParam.builder()
                        .model(model).apiKey(apiKey).format("wav").sampleRate(16000)
                        .vocabularyId(vocabulary.getVocabularyId()).build();
                System.out.println(recognizer.call(param, new File("asr-accuracy-example-en.wav")));
            } finally {
                recognizer.getDuplexApi().close(1000, "bye");
            }
        } finally {
            service.deleteVocabulary(vocabulary.getVocabularyId());
        }
        System.exit(0);
    }
}
import os
import dashscope

client = dashscope.Client(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    workspace="{WorkspaceId}",
    region="cn-beijing",
)
model = "qwen-audio-3.1-asr-flash-streaming"
vocabulary = client.audio.vocabularies.create(
    prefix="testpfx",
    target_model=model,
    vocabulary=[{"text": word, "weight": 4} for word in ["Kelyra"]],
)
try:
    if client.audio.vocabularies.get(vocabulary.vocabulary_id).status != "OK":
        raise RuntimeError("Vocabulary is not ready")
    for event in client.audio.asr.recognize_file(
        "asr-accuracy-example-en.wav", model=model, format="wav", sample_rate=16000,
        vocabulary_id=vocabulary.vocabulary_id,
    ):
        sentence = ((event.get("payload") or {}).get("output") or {}).get("sentence") or {}
        if sentence.get("text") and not sentence.get("heartbeat"):
            print(sentence["text"])
finally:
    client.audio.vocabularies.delete(vocabulary.vocabulary_id)

Use context enhancement

Contextual biasing can use existing conversation history or domain text directly. Hotwords require terms and weights, whereas context is sent as text messages without first turning business material into individual entries. Both methods can improve recognition of proper names. Choose based on the information available to your application.

Prepare context

For the sample audio, existing messages that spell the recipient’s name as “Kelyra” can provide its correct spelling. Two common sources of context are shown below.

Business or domain text

Use relevant text from an existing project description or domain material in a message with role=user and type=input_text. You do not need to invent a conversation or add a reply. Pass the following array as context:

[
  {
    "role": "user",
    "content": [
      {
        "type": "input_text",
        "text": "My colleague is Kelyra. We are preparing the quarterly project report."
      }
    ]
  }
]

Conversation history

Use existing recognized user text and model replies. User text uses role=user and type=input_text; replies use role=assistant and type=text. The following conversation already contains the target name and can provide context for subsequent recognition:

[
  {
    "role": "user",
    "content": [
      {
        "type": "input_text",
        "text": "My colleague is Kelyra. We are preparing the quarterly project report."
      }
    ]
  },
  {
    "role": "assistant",
    "content": [
      {
        "type": "text",
        "text": "Understood. We will send the quarterly project report to Kelyra."
      }
    ]
  }
]

NoteThe assistant message is optional. Order conversation history by turn, placing each user message before its corresponding assistant message. For text-length and retained-turn limits, see Usage limits.

Configure and call

Recognize the same audio with the prepared context. Choose a calling example by model family.

Qwen-Audio-ASR

This example uses qwen-audio-3.1-asr-flash. Place context messages in order in input.messages, followed by the current audio message containing input_audio.

curl --request POST 'https://{WorkspaceId}.cn-beijing.maas.aliyuncs.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_text",
            "text": "My colleague is Kelyra. We are preparing the quarterly project report."
          }
        ]
      },
      {
        "role": "assistant",
        "content": [
          {
            "type": "text",
            "text": "Understood. We will send the quarterly project report to Kelyra."
          }
        ]
      },
      {
        "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
  }
}
'

Qwen-Audio-ASR-Message / Qwen-Audio-ASR-Streaming

This example uses qwen-audio-3.1-asr-flash-streaming, which can also be replaced with qwen-audio-3.1-asr-flash-message. Pass context through input.context when starting the task.

NoteSDK examples require DashScope Python SDK 2.0.1 or later, or Java SDK 2.22.23 or later. See Install SDKs for installation.

import com.alibaba.dashscope.audio.asr.recognition.Recognition;
import com.alibaba.dashscope.audio.asr.recognition.RecognitionParam;
import com.alibaba.dashscope.utils.Constants;
import java.io.File;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) throws Exception {
        Constants.baseHttpApiUrl = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1";
        Constants.baseWebsocketApiUrl = "wss://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api-ws/v1/inference";
        Map<String, Object> userContent = new HashMap<>();
        userContent.put("type", "input_text");
        userContent.put("text", "My colleague is Kelyra. We are preparing the quarterly project report.");
        Map<String, Object> user = new HashMap<>();
        user.put("role", "user");
        user.put("content", Arrays.asList(userContent));
        Map<String, Object> assistantContent = new HashMap<>();
        assistantContent.put("type", "text");
        assistantContent.put("text", "Understood. We will send the quarterly project report to Kelyra.");
        Map<String, Object> assistant = new HashMap<>();
        assistant.put("role", "assistant");
        assistant.put("content", Arrays.asList(assistantContent));
        Map<String, Object> input = new HashMap<>();
        input.put("context", Arrays.asList(user, assistant));
        RecognitionParam param = RecognitionParam.builder()
                .model("qwen-audio-3.1-asr-flash-streaming")
                .apiKey(System.getenv("DASHSCOPE_API_KEY"))
                .format("wav").sampleRate(16000).input(input).build();
        Recognition recognizer = new Recognition();
        try {
            System.out.println(recognizer.call(param, new File("asr-accuracy-example-en.wav")));
        } finally {
            recognizer.getDuplexApi().close(1000, "bye");
        }
        System.exit(0);
    }
}
import os
import time
import dashscope
from concurrent.futures import ThreadPoolExecutor

client = dashscope.Client(
    api_key=os.environ["DASHSCOPE_API_KEY"],
    workspace="{WorkspaceId}",
    region="cn-beijing",
)
context = [
    {
        "role": "user",
        "content": [
            {
                "type": "input_text",
                "text": "My colleague is Kelyra. We are preparing the quarterly project report."
            }
        ]
    },
    {
        "role": "assistant",
        "content": [
            {
                "type": "text",
                "text": "Understood. We will send the quarterly project report to Kelyra."
            }
        ]
    }
]

def receive_events(recognition):
    for event in recognition.events():
        sentence = ((event.get("payload") or {}).get("output") or {}).get("sentence") or {}
        if sentence.get("text") and not sentence.get("heartbeat"):
            print(sentence["text"])

with client.audio.asr.recognize(
    model="qwen-audio-3.1-asr-flash-streaming",
    format="wav", sample_rate=16000,
    input={"context": context},
) as recognition:
    with ThreadPoolExecutor(max_workers=1) as pool:
        receiver = pool.submit(receive_events, recognition)
        try:
            with open("asr-accuracy-example-en.wav", "rb") as audio:
                while True:
                    chunk = audio.read(3200)
                    if not chunk:
                        break
                    recognition.send_audio_frame(chunk)
                    time.sleep(0.1)
            recognition.stop()
            receiver.result()
        finally:
            recognition.close()

Qwen-Audio-ASR-Filetrans

This example uses qwen-audio-3.1-asr-flash-filetrans. Supply audio URLs in input.file_urls and context in input.context, then submit an asynchronous task, query its status, and download the result.

import json
import os
import time
import urllib.request

base_url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"
headers = {"Authorization": "Bearer " + os.environ["DASHSCOPE_API_KEY"]}

def request_json(url, body=None, extra_headers=None):
    request_headers = {**headers, **(extra_headers or {})}
    data = None
    if body is not None:
        data = json.dumps(body, ensure_ascii=False).encode("utf-8")
        request_headers["Content-Type"] = "application/json"
    req = urllib.request.Request(url, data=data, headers=request_headers)
    with urllib.request.urlopen(req) as response:
        return json.load(response)

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"
        ],
        "context": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "My colleague is Kelyra. We are preparing the quarterly project report."
                    }
                ]
            },
            {
                "role": "assistant",
                "content": [
                    {
                        "type": "text",
                        "text": "Understood. We will send the quarterly project report to Kelyra."
                    }
                ]
            }
        ]
    },
    "parameters": {}
}
task = request_json(
    base_url + "/services/audio/asr/transcription", body,
    {"X-DashScope-Async": "enable"},
)
task_id = task["output"]["task_id"]
while True:
    result = request_json(base_url + "/tasks/" + task_id)
    status = result["output"]["task_status"]
    if status == "SUCCEEDED":
        break
    if status in ("FAILED", "CANCELED"):
        raise RuntimeError(result)
    time.sleep(1)

for item in result["output"]["results"]:
    if item["subtask_status"] != "SUCCEEDED":
        raise RuntimeError(item)
    with urllib.request.urlopen(item["transcription_url"]) as response:
        transcription = json.load(response)
    for transcript in transcription["transcripts"]:
        print(transcript["text"])

Remove the context configuration from the example and recognize the same audio to compare the results before and after configuration. Example transcripts are shown below:

ConfigurationExample transcript

Without configuration

Please send the quarterly project report to Kellira before Friday.

With configuration

Please send the quarterly project report to Kelyra before Friday.

Tune and troubleshoot recognition

Compare the same audio before and after configuration, then adjust entries, weights, or context. Hotword tuning applies to both instant and precompiled hotwords.

Adjust hotword weights

Regular hotword weights range from 1 to 5. Start at weight=4. A higher weight increases preference for the word, but an excessive weight can replace similar-sounding words incorrectly.

WeightPreferenceWhen to use

1–2

Slight

The term sounds like a common word and over-correction must be avoided

3–4

Moderate

Recommended starting configuration for most scenarios

5

Strong

Terms that appear frequently and are rarely confused with other words

Super hotwords: For both instant and precompiled hotwords, the Qwen-Audio-ASR-Message, Qwen-Audio-ASR-Streaming, Qwen-Audio-ASR-Filetrans, and Qwen-Audio-ASR series also support weight=50 to improve recall of target terms. Each vocabulary or request can contain at most 50 super hotwords.

Organize and maintain vocabularies

  • Group by scenario: Create separate precompiled lists for different business scenarios, such as medical terminology and product names, to reduce unrelated entries.

  • Distinguish entry language from audio language: A precompiled vocabulary can mix languages, identified by lang. The recognition parameter language_hints declares the audio language. When it is set, only hotwords in the matching language take effect; other languages are ignored.

  • Maintain regularly: Update entries as business needs change and delete unused lists to release quota.

NoteAllow at least 5 minutes between hotword list updates; otherwise, updated hotwords might not take effect.

Troubleshoot recognition quality

First identify whether the issue is an ineffective configuration, excessive bias toward hotwords, or audio that is difficult to recognize. Then check the relevant items below.

SymptomChecks and actions

Hotwords are not recognized as expected

Check Supported models and regions first. Instant hotwords belong in parameters.vocabulary. For precompiled hotwords, check the account, vocabulary_id, status=OK, and whether the list’s target_model matches the recognition model.

Increase the hotword weight within its supported range and compare results for the same audio to determine whether the weight was too low.

Other words are incorrectly replaced with hotwords

Reduce the hotword weight within its supported range and remove terms unrelated to the scenario. Check that lang matches the recognition API’s language_hints so that entries belong to the intended language.

Context does not improve target terms

Check the correct spellings, message roles, types, order, and the input field required by the API. Text beyond the length or turn limit can be truncated or discarded. See Usage limits.

Many ordinary words are also incorrect

Check that the audio format and sample rate meet the model requirements, and reduce background noise. For single-language audio, declare the language through the recognition API’s language_hints. For model selection and audio requirements, see Speech recognition overview.

Supported models and regions

Precompiled hotwords

Singapore

NoteHotwords are supported only in the primary workspace, not in sub-workspaces.

  • Qwen-Audio-ASR: qwen-audio-3.1-asr-flash, qwen-audio-3.0-asr-flash

  • Qwen-Audio-ASR-Streaming: qwen-audio-3.1-asr-flash-streaming, qwen-audio-3.0-asr-flash-streaming

  • Qwen-Audio-ASR-Filetrans: qwen-audio-3.1-asr-flash-filetrans, qwen-audio-3.0-asr-flash-filetrans

  • Qwen-Audio-ASR-Message: qwen-audio-3.1-asr-flash-message

  • Fun-ASR-Realtime: fun-asr-realtime

  • Fun-ASR-Flash: fun-asr-flash-2026-06-15

  • Fun-ASR: fun-asr

China (Beijing)

NoteHotwords are supported only in the primary workspace, not in sub-workspaces.

  • Qwen-Audio-ASR: qwen-audio-3.1-asr-flash, qwen-audio-3.0-asr-flash

  • Qwen-Audio-ASR-Streaming: qwen-audio-3.1-asr-flash-streaming, qwen-audio-3.0-asr-flash-streaming

  • Qwen-Audio-ASR-Filetrans: qwen-audio-3.1-asr-flash-filetrans, qwen-audio-3.0-asr-flash-filetrans

  • Qwen-Audio-ASR-Message: qwen-audio-3.1-asr-flash-message

  • Fun-ASR-Realtime: fun-asr-realtime, fun-asr-flash-8k-realtime, fun-asr-flash-8k-realtime-2026-01-28

  • Fun-ASR-Flash: fun-asr-flash-2026-06-15

  • Fun-ASR: fun-asr

  • Paraformer-Realtime: paraformer-realtime-v2, paraformer-realtime-8k-v2

  • Paraformer: paraformer-v2, paraformer-8k-v2

Instant hotwords

Singapore

NoteHotwords are supported only in the primary workspace, not in sub-workspaces.

  • Qwen-Audio-ASR: qwen-audio-3.1-asr-flash, qwen-audio-3.0-asr-flash

  • Qwen-Audio-ASR-Streaming: qwen-audio-3.1-asr-flash-streaming, qwen-audio-3.0-asr-flash-streaming

  • Qwen-Audio-ASR-Filetrans: qwen-audio-3.1-asr-flash-filetrans, qwen-audio-3.0-asr-flash-filetrans

  • Qwen-Audio-ASR-Message: qwen-audio-3.1-asr-flash-message

  • Fun-ASR: fun-asr

China (Beijing)

NoteHotwords are supported only in the primary workspace, not in sub-workspaces.

  • Qwen-Audio-ASR: qwen-audio-3.1-asr-flash, qwen-audio-3.0-asr-flash

  • Qwen-Audio-ASR-Streaming: qwen-audio-3.1-asr-flash-streaming, qwen-audio-3.0-asr-flash-streaming

  • Qwen-Audio-ASR-Filetrans: qwen-audio-3.1-asr-flash-filetrans, qwen-audio-3.0-asr-flash-filetrans

  • Qwen-Audio-ASR-Message: qwen-audio-3.1-asr-flash-message

  • Fun-ASR: fun-asr

Contextual biasing

Singapore

  • Qwen-Audio-ASR: qwen-audio-3.1-asr-flash, qwen-audio-3.0-asr-flash

  • Qwen-Audio-ASR-Streaming: qwen-audio-3.1-asr-flash-streaming, qwen-audio-3.0-asr-flash-streaming

  • Qwen-Audio-ASR-Filetrans: qwen-audio-3.1-asr-flash-filetrans, qwen-audio-3.0-asr-flash-filetrans

  • Qwen-Audio-ASR-Message: qwen-audio-3.1-asr-flash-message

  • Fun-ASR-Realtime: fun-asr-realtime

  • Fun-ASR-Flash: fun-asr-flash-2026-06-15

China (Beijing)

  • Qwen-Audio-ASR: qwen-audio-3.1-asr-flash, qwen-audio-3.0-asr-flash

  • Qwen-Audio-ASR-Streaming: qwen-audio-3.1-asr-flash-streaming, qwen-audio-3.0-asr-flash-streaming

  • Qwen-Audio-ASR-Filetrans: qwen-audio-3.1-asr-flash-filetrans, qwen-audio-3.0-asr-flash-filetrans

  • Qwen-Audio-ASR-Message: qwen-audio-3.1-asr-flash-message

  • Fun-ASR-Realtime: fun-asr-realtime

  • Fun-ASR-Flash: fun-asr-flash-2026-06-15

Usage limits

Hotword limits

LimitDescription

Number of hotword lists

Up to 50 precompiled vocabularies per account, shared across all models. Each vocabulary has a vocabulary_id.

Hotwords

Qwen-Audio-ASR-Message, Qwen-Audio-ASR-Streaming, Qwen-Audio-ASR-Filetrans, and Qwen-Audio-ASR series: up to 2000.

Main-version models in the Fun-ASR-Realtime, Fun-ASR-Flash, and Fun-ASR series: up to 2000. Other models in these series and the Paraformer series: up to 500.

Counts apply per vocabulary for precompiled hotwords and per request for instant hotwords.

Super hotwords

A maximum of 50 entries can have a weight of 50.

NoteFor the Qwen-Audio-ASR-Message, Qwen-Audio-ASR-Streaming, Qwen-Audio-ASR-Filetrans, and Qwen-Audio-ASR series, when both precompiled and instant hotwords are configured, the service merges the two sets. If the merged set exceeds 2000 hotwords, it randomly selects 2000 to use.

Hotword text rules

Hotwords must be actual words in a language supported by the model. The following rules apply to both instant and precompiled hotwords.

Contains non-ASCII characters

If a hotword contains non-ASCII characters, such as Chinese characters, Japanese kana, Korean Hangul, or Cyrillic letters, its total length, including ASCII characters and spaces, must not exceed 15 characters.

TextCountWithin length limit

"厄洛替尼盐酸盐"

7 characters

Yes

"EGFR抑制剂"

7 characters

Yes

"こんにちは"

5 characters

Yes

"Фенибут Белфарм"

15 characters

Yes

"Клофелин Белмедпрепараты"

24 characters

No

ASCII characters only

If a hotword contains only ASCII characters, it must have no more than 7 space-separated segments.

TextCountWithin length limit

"Exothermic reaction"

2 segments

Yes

"Human immunodeficiency virus type 1"

5 segments

Yes

"The effect of temperature variations on enzyme activity in biochemical reactions"

11 segments

No

Context limits

LimitDescription

Conversation turns

At most the latest 5 turns are retained, with up to 5 messages of each type: input_text and text. Older messages are ignored without an error. Domain text alone is also subject to the text length limit.

Text per turn

The combined length of text fields in all user and assistant messages in a turn must not exceed 400 characters. Letters, Chinese characters, digits, spaces, and punctuation each count as 1. Excess text is truncated from the end without an error. Each turn is counted independently.

NoteQwen-Audio-ASR-Message also supports updating context during a running task with continue-task. See Message client events for the format.

Feature billing

Instant and precompiled hotword features are free. For model invocation charges when using hotwords or contextual biasing, see billing rules.