Alibaba Cloud Model Studio:Qwen-Audio-3.0-ASR-Flash-Streaming/Fun-ASR-Realtime Python SDK

model

str

Yes

The model name. The Qwen-Audio-3.0-ASR-Flash-Streaming and Fun-ASR-Realtime model series are supported. For details, see Supported models and regions.

sample_rate

int

Yes

The sample rate, in Hz.

Valid values: 8 kHz models support only 8000 Hz; other models support any sample rate.

format

str

Yes

The audio format.

Valid values:

• pcm
• wav
• mp3
• opus
• speex
• aac
• amr

vocabulary_id

str

No

The ID of a precompiled hot word list.

Generate this ID in advance by calling the create hot word list API. Pass the ID during recognition to use the hot words in the list.

Suitable for scenarios where the vocabulary is known and relatively stable, and where you need to reuse the same word list across requests.

For usage details, see Precompiled hotwords.

vocabulary

dict

No

Instant hot words.

Passed as key-value pairs, where the key is the hot word text (string) and the value is the hot word weight (integer). No hot word list needs to be created in advance. The weight ranges from [1, 5] or is set to 50: a value in [1, 5] makes the model more likely to output the word as the value increases; a value of 50 designates a super hot word, which greatly improves recall, but the number of super hot words cannot exceed 50.

Suitable for temporary, session-level hot word optimization.

When instant and precompiled hotwords are configured together, the system merges both sets. If the merged set contains more than 2000 hotwords, the system randomly selects 2000 to use. For usage details, see Instant hotwords.

Example:

from dashscope.audio.asr import Recognition

vocab = {"John Smith": 5, "Jane Doe": 5}
recognition = Recognition(
    model='qwen-audio-3.0-asr-flash-streaming',
    format='wav',
    sample_rate=16000,
    vocabulary=vocab,
    callback=None)

semantic_punctuation_enabled

bool

No

Whether to enable semantic segmentation.

Default: False.

• True: Enables semantic segmentation and disables VAD segmentation.
• False (default): Enables VAD segmentation and disables semantic segmentation.

Semantic segmentation is more accurate and suits meeting transcription. VAD (Voice Activity Detection) segmentation has lower latency and suits interactive scenarios.

max_sentence_silence

int

No

The VAD silence threshold for segmentation, in ms. When the silence after a segment of speech exceeds this threshold, the system determines that the sentence has ended. When semantic_punctuation_enabled is set to true, this parameter is not used as the criterion for returning sentence_end, but setting it too low may affect recognition performance.

Default value: 1300.

Valid values: [200, 6000].

multi_threshold_mode_enabled

bool

No

Whether to enable multi-threshold mode. When enabled, it prevents VAD segmentation from producing segments that are too long.

Default: False.

punctuation_prediction_enabled

bool

No

Whether to automatically add punctuation to recognition results:

• True (default): Yes. This value cannot be changed.

heartbeat

bool

No

Whether to enable heartbeat packets.

Default: False.

• True: Keeps the connection to the server alive while silent audio is sent continuously.
• False (default): Even when silent audio is continuously sent, the connection times out and closes after a period of time.

Silent audio refers to content in an audio file or data stream that contains no sound signal. You can generate silent audio in several ways, such as using audio editing software like Audacity or Adobe Audition, or using a command-line tool like FFmpeg.

This field requires SDK version 1.23.1 or later.

language_hints

list[str]

No

The language of the audio to recognize. There is no default value; if not set, the model detects the language automatically.

For the Qwen-Audio-3.0-ASR-Flash-Streaming model series, you can set up to 4 values; if you set more than 4, only the first 4 take effect. For the Fun-ASR-Realtime model series, you can set only 1 value; if you set multiple values, only the first one takes effect.

speech_noise_threshold

float

No

The threshold for distinguishing speech from noise, used to adjust the sensitivity of Voice Activity Detection (VAD).

Valid values: [-1.0, 1.0].

Value descriptions:

• The closer the value is to -1: The noise threshold decreases, so noise is more likely to be recognized as speech, which may cause more noise to be transcribed.
• The closer the value is to +1: The noise threshold increases, so speech is more likely to be misjudged as noise, which may cause some speech to be filtered out.

This is an advanced configuration parameter. Adjusting it can significantly affect recognition results. Recommendations:

• Thoroughly test and verify the results before adjusting.
• Adjust in small increments based on the actual audio environment (a step of 0.1 is recommended).

special_word_filter

str

No

Specifies the sensitive words to process during speech recognition, and supports setting different processing methods for different sensitive words. For details, see Sensitive word filtering.

callback

RecognitionCallback

No

Callback interface (RecognitionCallback).

raw_input

dict

No

The input object used to pass in the conversation context. Context enhancement improves recognition accuracy for domain-specific terms. For usage, see Quick start.

The dict must include a context key whose value is a list of messages (list[dict]). Each message contains the following fields:

• role (str, required): The message role. user represents the recognition results from previous user turns or a domain-specific word list. assistant represents the large language model responses from previous turns.
• content (list[dict], required): The list of message content. Each element contains type (str; set to input_text when role is user, and text when role is assistant) and text (str, the text content).

# Build the input to pass in
      input_context = {
          "context": [
              {
                  "role": "user",
                  "content": [
                      {
                          "type": "input_text",
                          "text": "Hello there"
                      }
                  ]
              },
              {
                  "role": "assistant",
                  "content": [
                      {
                          "type": "text",
                          "text": "Hello, I am Qwen. How can I help you?"
                      }
                  ]
              }
          ]
      }

      # Pass it in through the raw_input parameter
      recognition.start(raw_input=input_context)
      # Or
      recognition.call(raw_input=input_context)

call

def call(self, file: str, phrase_id: str = None, **kwargs) -> RecognitionResult

A non-streaming call based on a local file. This method blocks the current thread until all audio is read, and requires read permission on the file.

The recognition result is returned as a RecognitionResult object.

start

def start(self, phrase_id: str = None, **kwargs)

Starts speech recognition.

A callback-based streaming real-time recognition. This method does not block the current thread. Use it together with send_audio_frame and stop.

send_audio_frame

def send_audio_frame(self, buffer: bytes)

Pushes audio. Keep each pushed audio frame neither too large nor too small: about 100 ms per frame, between 1 KB and 16 KB.

Recognition results are obtained through the on_event method of the Callback interface (RecognitionCallback).

stop

def stop(self)

Stops speech recognition. Blocks until the server finishes recognizing all received audio, then ends the task.

get_last_request_id

def get_last_request_id(self)

Gets the request_id. Available after the constructor is called (the object is created).

get_first_package_delay

def get_first_package_delay(self)

Gets the first-packet delay: the latency from sending the first audio packet to receiving the first recognition result. Use it after the task completes.

get_last_package_delay

def get_last_package_delay(self)

Gets the last-packet delay: the time from sending the stop command to receiving the last recognition result. Use it after the task completes.

get_response

def get_response(self)

Gets the last message. Use it to retrieve a task-failed error.

def on_open(self) -> None

None

None

Called immediately after the connection to the server is established.

def on_event(self, result: RecognitionResult) -> None

result: Recognition result (RecognitionResult)

None

Called when the server has a response.

def on_complete(self) -> None

None

None

Called after all recognition results are returned.

def on_error(self, message: str) -> None

result: Recognition result (RecognitionResult)

None

Called when an error occurs.

def on_close(self) -> None

None

None

Called after the server closes the connection.

get_sentence

def get_sentence(self) -> Union[Dict[str, Any], List[Any]]

Gets the current recognized sentence and its timestamp information. A callback returns a single sentence, so this method returns Dict[str, Any].

For details, see Sentence (Sentence).

get_request_id

def get_request_id(self) -> str

Gets the request_id of the request.

is_sentence_end

@staticmethod
def is_sentence_end(sentence: Dict[str, Any]) -> bool

Determines whether the given sentence has ended. This method checks whether the end_time field in sentence is None: a non-None end_time indicates that the sentence has ended. Call it as RecognitionResult.is_sentence_end(sentence), where sentence is the single-sentence dict returned by get_sentence(), not a boolean field on a Sentence instance.

begin_time

int

Sentence start time, in ms.

end_time

int

Sentence end time, in ms.

text

str

Recognized text.

words

A list of Word-level timestamp information (Word)

Word-level timestamp information.

begin_time

int

Word start time, in ms.

end_time

int

Word end time, in ms.

text

str

The word.

punctuation

str

The punctuation.