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.
| Method | When to use | How to use |
|---|---|---|
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. | |
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. | |
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.
-
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 } } ' -
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:
| Configuration | Example 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:
| Field | Type | Required | Description |
|---|---|---|---|
| string | Yes | An actual word in a language supported by the selected model. For length requirements, see Hotword text rules. |
| 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. |
| string | No | Language code that determines which language the entry applies to. Omit it if unknown. For its relationship with the recognition parameter |
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
-
Create a hotword list
This example uses
qwen-audio-3.1-asr-flashand specifies the target model throughtarget_model. Saveoutput.vocabulary_idfrom 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 -
Check that the list is ready
Replace
<vocabulary_id>with the ID returned by the create request, then query the list. Proceed with recognition whenoutput.statusisOK.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 -
Reference the list during recognition
Reference the list through
parameters.vocabulary_idin 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 -
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:
| Configuration | Example 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.
| Weight | Preference | When 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 parameterlanguage_hintsdeclares 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.
| Symptom | Checks and actions |
|---|---|
Hotwords are not recognized as expected | Check Supported models and regions first. Instant hotwords belong in 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 |
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 |
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
| Limit | Description |
|---|---|
Number of hotword lists | Up to 50 precompiled vocabularies per account, shared across all models. Each vocabulary has a |
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.
| Text | Count | Within length limit |
|---|---|---|
| 7 characters | Yes |
| 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.
| Text | Count | Within length limit |
|---|---|---|
| 2 segments | Yes |
| 5 segments | Yes |
| 11 segments | No |
Context limits
| Limit | Description |
|---|---|
Conversation turns | At most the latest 5 turns are retained, with up to 5 messages of each type: |
Text per turn | The combined length of |
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.
Related APIs
-
For creating, querying, updating, and deleting hotword lists, see Hotword management API.
-
Hotword management SDKs: Java SDK and Python SDK.
-
Model invocation APIs: Qwen-Audio-ASR-Message client events, Qwen-Audio-ASR-Streaming client events, Qwen-Audio-ASR-Filetrans HTTP API, and Qwen-Audio-ASR HTTP API.