BRASILTradução de apoio para consulta. Código e identificadores técnicos preservados. Consultar referência original ↗
Transcrição de arquivo de áudio
Converta arquivos em texto
Modelos de reconhecimento de fala não em tempo real convertem áudio gravado em texto. Eles apoiam reconhecimento multilingue, reconhecimento de canto, rejeição de ruído, e diarização de falantes, o que os torna adequados para atender transcrição, análise de chamadas, geração de legendas, e cenários semelhantes.
QwenCloud Também ofereceQwen-ASRPara reconhecimento com compreensão semântica melhorada eQwen-Omni** para transcrição baseada em um rápido entendimento contextual.
Para a disponibilidade de modelos, idiomas suportados e comparação de características, veja [Modelos de voz para texto] (/developer-guides/speech/speech-to-text-models).
Características principais
- Reconhecimento multilingue: reconhece chinês (incluindo vários dialetos), inglês, japonês, coreano, alemão, francês, russo e mais de 30 idiomas.
- Compatibilidade formal**: Aceita qualquer taxa de amostragem e suporta grandes formatos de áudio e vídeo, incluindo AAC, WAV e MP3.
- Processamento de arquivos de áudio longo**: lida com transcrição assíncrona para um único arquivo de áudio de até 12 horas de duração e 2 GB de tamanho. Se a diarização do alto-falante estiver ativa, áudio maior que 2 horas não é recomendado.
- Transcreve músicas inteiras, mesmo com música de fundo (BGM). Só o fun-asr O modelo suporta essa característica.
- Características configuráveis incluem diarização de alto-falantes, filtragem sensível de palavras, timestamps de nível de frase e nível de palavras, e aprimoramento de palavras quentes.
Modelos apoiados.
- 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 (estável)
- Fun-ASR-Flash: fun-asr-flash-2026-06-15 (Snapshot)
- Qwen3-ASR-Flash-Filetrans: qwen3-asr-flash-filetrans (estável)
- Qwen3-ASR-Flash: qwen3-asr-flash (estável)
Pré-requisitos
- [Pegue uma chave API] (/api-reference/preparation/api-keyE o define como uma variável de ambiente./api-reference/preparation/export-api-key-env).
- Para chamar a API através do DashScope SDK, [instalar o mais recente SDK] (/api-reference/preparation/install-sdk).
Começando.
Qwen-Audio-3.x-ASR-Flash-Filetrans/Fun-ASR
### - A disponibilidade do modelo.
| Modelo | Versão | Preço unitário | Quota livre(Nota) |
|---|---|---|---|
| fun-asr | Estável. | US$ 0.000035/second | 36 mil segundos (10 horas) Válido por 90 dias. |
| fun-asr-flash-2026-06-15 Suporta chamadas sincronizadas (até 5 minutos) e melhoria de contexto |
Deslize | US$ 0.000035/second | 36 mil segundos (10 horas) Válido por 90 dias. |
- Linguagens suportadas:
- fun-asr(30 línguas) (/api-reference/speech-recognition/fun-asr-recording/restful-api#supported-languages)
- * Taxas de amostragem suportadas *
- ** Formatos de áudio suportados**: aac, amr, avi, flac, flv, m4a, mkv, mov, mp3, mp4, mpeg, ogg, opus, wav, webm, wma, wmv
### Faça sua primeira ligação.
[Pegue uma chave API] (/api-reference/preparation/api-keyE o define como uma variável de ambiente./api-reference/preparation/export-api-key-env). Para usar o SDK, [instale-o] (/api-reference/preparation/install-sdk).
Porque arquivos de áudio e vídeo são grandes, transferência de arquivos e reconhecimento de fala podem levar muito tempo. A API de reconhecimento de arquivos usa invocação assíncrona para enviar tarefas. Depois que o reconhecimento do arquivo estiver completo, você deve usar a API de consulta para recuperar os resultados do reconhecimento de fala.
#### Async, submeta e sincronize, espere.
Submeta uma tarefa e bloqueie até que seja feito.
```python Python
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)
```
```java Java
import com.alibaba.dashscope.audio.asr.transcription.*;
import com.alibaba.dashscope.utils.Constants;
import com.google.gson.*;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
Constants.baseHttpApiUrl = "https://maas.qwencloudapi.com/api/v1";
// Create transcription request parameters.
TranscriptionParam param =
TranscriptionParam.builder()
// If you have not configured an environment variable, replace the following line with your API key: .apiKey("sk-xxx")
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
.model("qwen-audio-3.1-asr-flash-filetrans")
// 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.
.parameter("language_hints", new String[]{"zh", "en"})
.fileUrls(
Arrays.asList(
"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"))
.build();
try {
Transcription transcription = new Transcription();
// Submit the transcription request.
TranscriptionResult result = transcription.asyncCall(param);
System.out.println("RequestId: " + result.getRequestId());
// Check whether the task was submitted successfully.
if (result.getTaskId() == null) {
System.out.println("Error: " + result.getOutput());
System.exit(1);
}
// Block and wait for the task to complete and get the result.
result = transcription.wait(
TranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
// Get the transcription result.
List<TranscriptionTaskResult> taskResultList = result.getResults();
if (taskResultList != null && taskResultList.size() > 0) {
for (TranscriptionTaskResult taskResult : taskResultList) {
String transcriptionUrl = taskResult.getTranscriptionUrl();
HttpURLConnection connection =
(HttpURLConnection) new URL(transcriptionUrl).openConnection();
connection.setRequestMethod("GET");
connection.connect();
BufferedReader reader =
new BufferedReader(new InputStreamReader(connection.getInputStream()));
Gson gson = new GsonBuilder().setPrettyPrinting().create();
JsonElement jsonResult = gson.fromJson(reader, JsonObject.class);
System.out.println(gson.toJson(jsonResult));
}
}
} catch (Exception e) {
System.out.println("error: " + e);
}
System.exit(0);
}
}
```
O resultado do reconhecimento completo é impresso no console no formato JSON. O resultado inclui o texto transcrito e os tempos de início e fim do texto no arquivo de áudio ou vídeo, especificado em milissegundos.
Primeiro resultado
```json
{
"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": ". "
}
]
}
]
}
]
}
```
Segundo resultado
```json
{
"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": ". "
}
]
}
]
}
]
}
```
#### Submeter e fazer uma pergunta
Envie uma tarefa e pesquise para resultados em vez de bloquear.
```python Python
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!')
```
```java Java
import com.alibaba.dashscope.audio.asr.transcription.*;
import com.alibaba.dashscope.common.TaskStatus;
import com.alibaba.dashscope.utils.Constants;
import com.google.gson.*;
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
Constants.baseHttpApiUrl = "https://maas.qwencloudapi.com/api/v1";
// Create transcription request parameters.
TranscriptionParam param =
TranscriptionParam.builder()
// If you have not configured an environment variable, replace the following line with your API key: .apiKey("sk-xxx")
.apiKey(System.getenv("DASHSCOPE_API_KEY"))
.model("qwen-audio-3.1-asr-flash-filetrans")
.fileUrls(
Arrays.asList(
"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"))
.build();
try {
Transcription transcription = new Transcription();
// Submit the transcription request.
TranscriptionResult result = transcription.asyncCall(param);
System.out.println("RequestId: " + result.getRequestId());
// Check whether the task was submitted successfully.
if (result.getTaskId() == null) {
System.out.println("Error: " + result.getOutput());
System.exit(1);
}
// Poll for the task execution result until the task is complete.
while (true) {
result = transcription.fetch(TranscriptionQueryParam.FromTranscriptionParam(param, result.getTaskId()));
if (result.getTaskStatus() == TaskStatus.SUCCEEDED || result.getTaskStatus() == TaskStatus.FAILED) {
break;
}
Thread.sleep(1000);
}
// Print the result.
System.out.println(new GsonBuilder().setPrettyPrinting().create().toJson(result.getOutput()));
} catch (Exception e) {
System.out.println("error: " + e);
}
System.exit(0);
}
}
```
#### API RESTful
Use qualquer biblioteca HTTP para enviar tarefas e pesquisas para resultados. Esta amostra Python demonstra o fluxo de trabalho:
```python
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)
```
#### Chamadas sincrônicas (Qwen-Audio-3.x-ASR-Flash/Fun-ASR-Flash)
O Qwen-Audio-3.x-ASR-Flash e Fun-ASR-Flash Série de modelos suportam chamadas sincronizadas para arquivos de áudio menores de 5 minutos. Os resultados podem ser retornados em modo de transmissão ou não.
```bash
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"
}
}'
```
**Responda nota estrutura:** Qwen-Audio-3.x-ASR-Flash e Fun-ASR-Flash A série de modelos retorna uma estrutura de resposta através da API síncrona DashScope (o endpoint multimodal) que difere do formato de resposta multimodal padrão DashScope. O texto reconhecido está disponível em `output.output.sentence.text` e `output.text` Na resposta, não em `output.choices[].message.content`. Quando analisar respostas desses modelos, use o `output.output` caminho para acessar os resultados do reconhecimento.
Exemplo de resposta:
```json
{
"output": {
"output": {
"sentence": {
"text": "Hello World, this is Alibaba Speech Lab."
}
},
"text": "Hello World, this is Alibaba Speech Lab."
},
"request_id": "..."
}
```
Qwen-ASR
Antes de começar, pegue uma chave API (/api-reference/preparation/api-key). Para usar o SDK, [instale-o] (/api-reference/preparation/install-sdk).
DashScope
Qwen3-ASR-Flash-Filetrans
Qwen3-ASR-Flash-Filetrans é projetado para transcrição assíncrona de arquivos de áudio e suporta gravações de até 12 horas de duração. Este modelo requer uma URL acessível publicamente de um arquivo de áudio como entrada e não suporta uploads diretos de arquivos locais. É uma API não-streaming que retorna o resultado completo de reconhecimento após a tarefa completa.
cURL
Quando você usa o CURL para reconhecimento de fala, primeiro envie uma tarefa para obter uma tarefa ID (tarefa\_id), e depois use o ID para recuperar o resultado da tarefa.
#### Submeta uma tarefa
```bash
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
}
}'
```
#### Obter o resultado da tarefa
```bash
curl -X GET 'https://maas.qwencloudapi.com/api/v1/tasks/{task_id}' \
-H "Authorization: Bearer $DASHSCOPE_API_KEY" \
-H "Content-Type: application/json"
```
#### Exemplo completo.
```java Java
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;
}
}
```
```python Python
import os
import time
import requests
import json
API_URL_SUBMIT = "https://maas.qwencloudapi.com/api/v1/services/audio/asr/transcription"
API_URL_QUERY_BASE = "https://maas.qwencloudapi.com/api/v1/tasks/"
def main():
# If you have not configured environment variables, replace the following line with: api_key = "sk-xxx"
api_key = os.getenv("DASHSCOPE_API_KEY")
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
"X-DashScope-Async": "enable"
}
# 1. Submit the task
payload = {
"model": "qwen3-asr-flash-filetrans",
"input": {
"file_url": "{YOUR_AUDIO_URL}"
},
"parameters": {
"channel_id": [0],
# "language": "zh",
"enable_itn": False,
"enable_words": True
}
}
print("Submitting ASR transcription task...")
try:
submit_resp = requests.post(API_URL_SUBMIT, headers=headers, data=json.dumps(payload))
except requests.RequestException as e:
print(f"Failed to submit task request: {e}")
return
if submit_resp.status_code != 200:
print(f"Task submission failed! HTTP code: {submit_resp.status_code}")
print(submit_resp.text)
return
resp_data = submit_resp.json()
output = resp_data.get("output")
if not output or "task_id" not in output:
print("Abnormal submission response content:", resp_data)
return
task_id = output["task_id"]
print(f"Task submitted. task_id: {task_id}")
# 2. Poll the task status
finished = False
while not finished:
time.sleep(2) # Wait for 2 seconds before querying again
query_url = API_URL_QUERY_BASE + task_id
try:
query_resp = requests.get(query_url, headers={"Authorization": f"Bearer {api_key}"})
except requests.RequestException as e:
print(f"Failed to query task: {e}")
return
if query_resp.status_code != 200:
print(f"Task query failed! HTTP code: {query_resp.status_code}")
print(query_resp.text)
return
query_data = query_resp.json()
output = query_data.get("output")
if output and "task_status" in output:
status = output["task_status"]
print(f"Current task status: {status}")
if status.upper() in ("SUCCEEDED", "FAILED", "UNKNOWN"):
finished = True
print("Task completed. Final result:")
print(json.dumps(query_data, indent=2, ensure_ascii=False))
else:
print("Query response content:", query_data)
if __name__ == "__main__":
main()
```
Java SDK
```java
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);
}
}
}
```
Python SDK
```python
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}')
```
Qwen3-ASR-Flash
Qwen3-ASR-Flash suporta gravações de até 5 minutos. Este modelo aceita um URL de arquivo de áudio acessível publicamente ou um upload direto de um arquivo local como entrada. Também pode retornar os resultados de reconhecimento como um fluxo.
#### Entrada: URL de arquivo de áudio
```python Python SDK
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)
```
```java Java SDK
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 com.alibaba.dashscope.utils.JsonUtils;
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();
MultiModalConversationResult result = conv.call(param);
System.out.println(JsonUtils.toJson(result));
}
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);
}
}
```
```bash cURL
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" \
-d '{
"model": "qwen3-asr-flash",
"input": {
"messages": [
{
"content": [
{
"text": ""
}
],
"role": "system"
},
{
"content": [
{
"audio": "{YOUR_AUDIO_URL}"
}
],
"role": "user"
}
]
},
"parameters": {
"asr_options": {
"enable_itn": false
}
}
}'
```
#### Entrada: arquivo de áudio codificado pela base 64
Dados codificados pela base de entrada64 ([ URL de dados])https://www.rfc-editor.org/rfc/rfc2397)) no formato: `data:<mediatype>;base64,<data>`.
- `<mediatype>`: Tipo MIME
Varia por formato de áudio, por exemplo:
- WAV: `audio/wav`
- - Sim. `audio/mpeg`
- `<data>`A string do áudio codificada pela base 64.
A codificação Base64 aumenta o tamanho do arquivo. Mantenha o arquivo original pequeno o suficiente para que os dados codificados permaneçam dentro do limite de entrada de 10 MB.
- Exemplo: `data:audio/wav;base64,SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU4LjI5LjEwMAAAAAAAAAAAAAAA//PAxABQ/BXRbMPe4IQAhl9`
Veja o código do exemplo.
```python Python
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}"
```
```java Java
import java.nio.file.*;
import java.util.Base64;
public class Main {
/**
* filePath is a local audio file for voice cloning. Replace it with your own audio file path and ensure it meets audio requirements
*/
public static String toDataUrl(String filePath) throws Exception {
byte[] bytes = Files.readAllBytes(Paths.get(filePath));
String encoded = Base64.getEncoder().encodeToString(bytes);
return "data:audio/mpeg;base64," + encoded;
}
// Usage example
public static void main(String[] args) throws Exception {
System.out.println(toDataUrl("{YOUR_AUDIO_FILE}"));
}
}
```
```python Python SDK
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)
```
```java Java SDK
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
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 com.alibaba.dashscope.utils.JsonUtils;
public class Main {
// Replace with your actual audio file path
private static final String AUDIO_FILE = "{YOUR_AUDIO_FILE}";
// Replace with your actual audio file MIME type
private static final String AUDIO_MIME_TYPE = "audio/mpeg";
public static void simpleMultiModalConversationCall()
throws ApiException, NoApiKeyException, UploadFileException, IOException {
MultiModalConversation conv = new MultiModalConversation();
MultiModalMessage userMessage = MultiModalMessage.builder()
.role(Role.USER.getValue())
.content(Arrays.asList(
Collections.singletonMap("audio", toDataUrl())))
.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();
MultiModalConversationResult result = conv.call(param);
System.out.println(JsonUtils.toJson(result));
}
public static void main(String[] args) {
try {
Constants.baseHttpApiUrl = "https://maas.qwencloudapi.com/api/v1";
simpleMultiModalConversationCall();
} catch (ApiException | NoApiKeyException | UploadFileException | IOException e) {
System.out.println(e.getMessage());
}
System.exit(0);
}
// Generate data URI
public static String toDataUrl() throws IOException {
byte[] bytes = Files.readAllBytes(Paths.get(AUDIO_FILE));
String encoded = Base64.getEncoder().encodeToString(bytes);
return "data:" + AUDIO_MIME_TYPE + ";base64," + encoded;
}
}
```
#### Entrada: caminho absoluto para o arquivo de áudio local
Ao usar o SDK DashScope para processar arquivos de áudio locais, você deve fornecer o caminho do arquivo. A tabela seguinte mostra como construir o caminho do arquivo para o seu cenário específico e sistema operacional.
| Sistema | SDK | Caminho do arquivo de entrada | Exemplo |
|---|---|---|---|
| Linux ou MacOS | Python SDK | file://<absolute file path> |
file:///home/audio/test.mp3 |
| Linux ou MacOS | Java SDK | file://<absolute file path> |
file:///home/audio/test.mp3 |
| Janelas | Python SDK | file://<absolute file path> |
file://D:/audio/test.mp3 |
| Janelas | Java SDK | file:///<absolute file path> |
file:///D:/audio/test.mp3 |
Quando se usa arquivos locais, o limite de chamada da API é 100 QPS e não pode ser escalado. Não use este método em ambientes de produção, cenários de alta concorrência, ou testes de estresse. Para maior concordância, envie arquivos para OSS e ligue para a API usando o URL do arquivo de áudio.
```python Python SDK
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)
```
```java Java SDK
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 com.alibaba.dashscope.utils.JsonUtils;
public class Main {
public static void simpleMultiModalConversationCall()
throws ApiException, NoApiKeyException, UploadFileException {
// Replace ABSOLUTE_PATH/{YOUR_AUDIO_FILE} with the absolute path to your local file
String localFilePath = "file://ABSOLUTE_PATH/{YOUR_AUDIO_FILE}";
MultiModalConversation conv = new MultiModalConversation();
MultiModalMessage userMessage = MultiModalMessage.builder()
.role(Role.USER.getValue())
.content(Arrays.asList(
Collections.singletonMap("audio", localFilePath)))
.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();
MultiModalConversationResult result = conv.call(param);
System.out.println(JsonUtils.toJson(result));
}
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);
}
}
```
#### Saída de transmissão
O modelo gera resultados incrementais ao invés de todos de uma vez. Saída sem fluxo espera até que o modelo termine de gerar e então retorna o resultado completo. A saída de fluxo retorna resultados intermediários em tempo real, permitindo que você leia os resultados conforme são gerados e reduzindo o tempo de espera. Defina parâmetros diferentes com base no seu método de chamada para permitir a saída de streaming:
- - Defina o código de segurança. `stream` parâmetro para verdadeiro.
- Use o `streamCall` Interface.
- Defina o código de segurança. `X-DashScope-SSE` - Para onde? `enable`.
Python SDK
```python
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
```
Java SDK
```java
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
```bash
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
}
}
}'
```
OpenAI compatible
Só o Qwen3-ASR-Flash Modelos de série suportam chamadas compatíveis com OpenAI. Modo compatível com OpenAI só aceita URLs de arquivos de áudio acessíveis publicamente e não suporta caminhos de arquivos locais.
Use a versão SDK OpenAI Python 1.52.0 ou posterior, e a versão SDK Node.js 4.68.0 ou posterior.
O `asr_options` O parâmetro não faz parte do padrão OpenAI. Ao usar o OpenAI Python SDK, passe-o através `extra_body`. Ao usar o **Node.js OpenAI SDK (v4.x)**, passe `asr_options` diretamente no objeto do corpo pedido em vez de embrulhá-lo em `extra_body`, como o SDK Node.js não suporta o `extra_body` Campo.
#### Entrada: URL de arquivo de áudio
Python SDK
```python
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}")
```
Node.js SDK
```javascript
// 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
```bash
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
}
}'
```
#### Entrada: arquivo de áudio codificado pela base 64
Dados codificados pela base de entrada64 ([ URL de dados])https://www.rfc-editor.org/rfc/rfc2397)) no formato: `data:<mediatype>;base64,<data>`.
- `<mediatype>`: Tipo MIME
Varia por formato de áudio, por exemplo:
- WAV: `audio/wav`
- - Sim. `audio/mpeg`
- `<data>`A string do áudio codificada pela base 64.
A codificação Base64 aumenta o tamanho do arquivo. Mantenha o arquivo original pequeno o suficiente para que os dados codificados permaneçam dentro do limite de entrada de 10 MB.
- Exemplo: `data:audio/wav;base64,SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU4LjI5LjEwMAAAAAAAAAAAAAAA//PAxABQ/BXRbMPe4IQAhl9`
Veja o código do exemplo.
```python Python
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}"
```
```java Java
import java.nio.file.*;
import java.util.Base64;
public class Main {
/**
* filePath is a local audio file for voice cloning. Replace it with your own audio file path and ensure it meets audio requirements
*/
public static String toDataUrl(String filePath) throws Exception {
byte[] bytes = Files.readAllBytes(Paths.get(filePath));
String encoded = Base64.getEncoder().encodeToString(bytes);
return "data:audio/mpeg;base64," + encoded;
}
// Usage example
public static void main(String[] args) throws Exception {
System.out.println(toDataUrl("{YOUR_AUDIO_FILE}"));
}
}
```
Python SDK
```python
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}")
```
Node.js SDK
```javascript
// 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();
```
Qwen-Omni
Use **Qwen-Omni** (`qwen3.5-omni-plus`, `qwen3.5-omni-flash`, `qwen3-omni-flash`) para transcrição de arquivos com contexto baseado em alerta. Essa abordagem permite descrever seu domínio no sistema para uma precisão melhor.
Qwen-Omni interpreta todo o áudio, não apenas o discurso. Música, digitação ou ruído ambiente podem produzir descrições em vez de transcrição. Para áudio misto, pré-processo com DAV para isolar a fala, ou adicionar uma instrução rápida do sistema: "Transcreva apenas a fala humana. Ignore sons não falantes."
[Pegue uma chave API] (/api-reference/preparation/api-keyE o define como uma variável de ambiente./api-reference/preparation/export-api-key-env(Instalar o SDK] (/api-reference/preparation/install-sdk).
```python Python
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="")
```
```bash cURL
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-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
}'
```
Para completar Qwen-Omni Capacitação incluindo conversa multimodal, veja [Audio e compreensão de arquivos de vídeo]/developer-guides/speech/multimodal-speech).
Melhoramento de contexto
Modelos apoiados: Qwen-Audio-3.x-ASR-Flash (qwen-audio-3.1-asr-flash) e Fun-ASR-Flash (fun-asr-flash-2026-06-15) apoio ao aumento do contexto.
**Caso de uso:**Projetado para cenários que combinam ASR com um modelo de linguagem grande. Passando o contexto de conversação anterior (repostas do LLM e resultados de reconhecimento anteriores) no modelo ASR melhora significativamente a precisão de transcrição para substantivos adequados, como nomes, locais e termos de produtos - mais flexíveis do que palavras quentes tradicionais.
Passe a história da conversa input.messages. Use o assistant O papel para as respostas anteriores da LLM e o user - O papel com input_text Tipo para resultados de reconhecimento mais adiantados. Os pares de contexto devem aparecer antes da mensagem de áudio atual.
** Tipos de texto suportados** incluem (mas não estão limitados a):
- Listas de palavras em vários formatos delimitadores (por exemplo: hotword1, hotword2, hotword3, hotword4)
- Parágrafos ou passagens de qualquer comprimento
- Conteúdo misto: qualquer combinação de listas de palavras e parágrafos
- Texto irrelevante ou sem sentido, incluindo palavrões. O modelo tolera conteúdo irrelevante bem, e qualidade de reconhecimento raramente se degrada por causa disso.
Exemplo:
Considere um clipe de áudio cuja transcrição correta é: "Que jargão interno você conhece em investimento bancário? Primeiro, os nove melhores bancos estrangeiros de investimento, Bulge Bracket, BB..."
| Sem o realce do contexto | Com o aprimoramento do contexto |
|---|---|
| Sem o aprimoramento do contexto, alguns nomes de bancos de investimento são mal reconhecidos. Por exemplo, "Pedra do Pássaro" deve ser "Bulge Bracket". Resultado: "Que jargão interno você conhece em investimento bancário? Primeiro, os nove maiores bancos de investimento estrangeiros, Bird Rock, BB..." |
Com o aprimoramento do contexto, os nomes dos bancos de investimento são reconhecidos corretamente. Resultado: "Que jargão interno você conhece em investimento bancário? Primeiro, os nove melhores bancos estrangeiros de investimento, Bulge Bracket, BB..." |
Resultado: "Que jargão interno você conhece em investimento bancário? Primeiro, os nove maiores bancos de investimento estrangeiros, Bird Rock, BB... com o aprimoramento do contexto, os nomes dos bancos de investimento são reconhecidos corretamente.
Resultado: "Que jargão interno você conhece em investimento bancário? Primeiro, os nove maiores bancos de investimento estrangeiros, Bulge Bracket, BB..."
Para produzir o resultado corrigido, inclua qualquer um dos seguintes no contexto:
- Uma lista de palavras:
- Lista 1:
Bulge Bracket, Boutique, Middle Market, domestic securities firms
- Lista 2:
Bulge Bracket Boutique Middle Market domestic securities firms
- Lista 3:
['Bulge Bracket', 'Boutique', 'Middle Market', 'domestic securities firms']
- Linguagem natural:
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.
- Linguagem natural com conteúdo distraídor: algum texto não tem relação com o áudio, como os nomes no exemplo abaixo.
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
Recursos avançados
Além de [melhoramento do contexto] (#context-enhancement), a transcrição de arquivos de áudio suporta as seguintes capacidades. Para criar e usar palavras quentes, veja [Melhorar precisão de reconhecimento] (/developer-guides/speech/improve-recognition-accuracy).
Processamento de arquivos de áudio longo
A transcrição de arquivos de áudio suporta transcrição assíncrona de áudio longo, que combina com a hora de reunião, notas de entrevista e chamada de reprodução.
Limites*:
- **Qwen-Audio-3.x-ASR-Flash-Filetrans/Fun-ASR/Qwen3-ASR-Flash-Filetrans Cada arquivo de áudio não deve ser maior que 2 GB e não mais que 12 horas.
- **Qwen-Audio-3.1-ASR-Flash Cada arquivo de áudio não deve ser maior que 2 GB e não mais que 5 minutos.
- **Qwen-Audio-3.x-ASR-Flash/Fun-ASR-Flash/Qwen3-ASR-Flash Cada arquivo de áudio não deve ser maior que 10 MB e não mais que 5 minutos. Para mais áudio, use Qwen-Audio-3.1-ASR-Flash-Filetrans, Fun-ASR, ou Qwen3-ASR-Flash-Filetrans.
- Áudio maior que 2 horas não é recomendado, porque o reconhecimento pode falhar ou parar. Veja, é a sua voz.#speaker-diarization).
A transcrição de áudio longa usa um modelo assíncrono de tarefa com três passos:
- Envie a tarefa de transcrição e consiga um
task_id. - Procure pelo status da tarefa, ou use o método de espera do SDK para bloquear até que a tarefa termine.
- Quando a tarefa terminar, baixe o resultado JSON da URL devolvida.
Para amostras de código, veja [Começando] (#getting-started). Para intervalos de votação e gerenciamento de tarefas em lote, veja [Gestão de tarefas assíncrona] (/developer-guides/run-and-scale/async-task-management).
Diarização do presidente da câmara
A diarização do alto-falante identifica diferentes falantes no áudio e etiqueta cada frase no resultado da transcrição, que combina com reuniões multipessoas e gravações de entrevistas.
**Qwen-Audio-3.1-ASR-Flash Permite a diarização com o alto-falante. speaker_diarization_enabled. Para seus parâmetros e estrutura de resposta, veja [A API RESTful] (/api-reference/speech-recognition/fun-asr-recording/restful-api).
Modelos apoiados: Qwen-Audio-3.x-ASR-Flash-Filetrans, Fun-ASRE Paraformer.
** Como ativar **: Set diarization_enabled para true nos parâmetros de solicitação. Cada sentença no resultado, então inclui um speaker_id campo que identifica o alto-falante.
Estrutura de resposta (excerto):
{
"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 }
]
}
]
}
Quando a diarização do alto-falante é ativada, áudio maior que 2 horas não é recomendado, porque o reconhecimento pode falhar ou parar. Para os limites de duração que se aplicam quando a diarização está desligada, veja [Long audio file processing] (#long-audio-file-processing). A diarização do alto-falante suporta apenas áudio mono.
Os SDKs expõem esses campos com diferentes convenções de nomes (chaves dicionárias, propriedades de objetos ou métodos). Para o mapeamento completo do campo, veja [referência API] (#api-reference).
Filtragem sensível de palavras
A filtragem sensível de palavras substitui ou remove palavras sensíveis no resultado do reconhecimento, que se adequa a qualidade do serviço ao cliente, conformidade de conteúdo e revisão de legendas.
Modelos apoiados: Qwen-Audio-3.x-ASR-Flash-Filetrans, Fun-ASRE Paraformer.
Se você não passar no teste, eu vou te dar um jeito. special_word_filter parâmetro, a lista de palavras sensitivas se aplica e as palavras correspondentes são substituídas por um número igual de asteriscos (*).
** Configuração personalizada**: special_word_filter é um objeto JSON com três sub-campos:
filter_with_signed.word_listUma série de palavras sensíveis para substituir por um número igual de asteriscos. Por exemplo, com["test"]"Execute um teste para mim" se torna "Execute um teste para mim".filter_with_empty.word_listUma série de palavras sensíveis para remover inteiramente do resultado. Por exemplo, com["start"]"O jogo está prestes a começar" se torna "O jogo está prestes a começar".system_reserved_filterUm booleano que é o padrãotrue. Especifica se também deve aplicar a lista de palavras confidenciais, que é combinada com suas listas personalizadas.
Configuração do exemplo:
{
"special_word_filter": {
"filter_with_signed": {
"word_list": ["test"]
},
"filter_with_empty": {
"word_list": ["start", "happen"]
},
"system_reserved_filter": true
}
}
O padrão difere de [reconhecimento de fala em tempo real] (/developer-guides/speech/asr-realtimeNo reconhecimento em tempo real, não é aplicada filtragem quando special_word_filter é omitido, porque system_reserved_filter predefinições para false.
Reconhecimento de emoções
Qwen3-ASR-Flash-Filetrans e Qwen3-ASR-Flash Sempre realizar reconhecimento emocional, sem configuração extra. O resultado inclui o rótulo emocional do orador, que é um dos sete valores: surprised, neutral, happy, sad, disgusted, angry, e fearful.
Caminhos de campo (variam pela interface):
- ** Interface compatível com o OpenAI** (Qwen3-ASR-Flash):
choices[].delta.annotations[].emotionpara transmissão de saída, ouchoices[].message.annotations[].emotionpara saída sem fluxo. - DashScope interface síncrona (Qwen3-ASR-Flash):
output.choices[].message.annotations[].emotion. - DashScope assíncrona interface de tarefas (Qwen3-ASR-Flash-Filetrans):
transcripts[].sentences[].emotion, ao lado dos campos de tempo em cada objeto de frase.
Estrutura de resposta (Interface de tarefas assíncronas DashScope, excerto):
{
"transcripts": [{
"sentences": [{
"begin_time": 0,
"end_time": 1440,
"text": "Welcome to QwenCloud.",
"emotion": "neutral",
"language": "en"
}]
}]
}
Qwen-Audio-3.x-ASR-Flash-Filetrans, Qwen-Audio-3.x-ASR-Flash, Fun-ASR-Flash, Fun-ASRE Paraformer não suporta reconhecimento emocional. Para usar o reconhecimento de emoções em cenários em tempo real, veja/developer-guides/speech/asr-realtime).
Pegue as datas.
A transcrição de arquivos de áudio pode retornar datas no resultado, que se encaixa na geração de legendas, destaque de palavras-chave e edição de áudio ou vídeo. O comportamento padrão e os controles variam de acordo com o modelo:
-
**Qwen-Audio-3.x-ASR-Flash-Filetrans/Qwen-Audio-3.x-ASR-Flash/Fun-ASR/Fun-ASR-Flash Os horários estão sempre ligados e não podem ser desligados.
-
**Qwen3-ASR-Flash-FiletransAs datas são suportadas apenas através da interface assíncrona DashScope, onde elas estão sempre ligadas. Use o
enable_wordsparâmetro de solicitação para controlar a granularidade:falseRetorno de horários de nível de sentença, etrueretorna as datas de nível de palavras. Horários de nível de palavras são suportados apenas para chinês, inglês, japonês, coreano, alemão, francês, espanhol, italiano, português e russo. A precisão não é garantida para outras línguas.Quando você chama Qwen3-ASR-Flash através da interface compatível com OpenAI, a saída é uma
chat.completionobjeto e não contém campos de timestamp. Se precisar de hora, use Qwen3-ASR-Flash-Filetrans através da interface de tarefas assíncronas.
As datas estão em milissegundos e são devolvidas em dois níveis:
- ** Nível de sentença**:
sentences[].begin_timeesentences[].end_timeMarque o início e o fim de cada frase no áudio. - ** Nível de palavras**:
sentences[].words[]Array, onde cada elemento contémbegin_time,end_time, etext(a palavra).
Estrutura de resposta (Interface de tarefas assíncronas DashScope, excerto):
{
"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" }
]
}]
}]
}
As datas dentro do áudio são milissegundos inteiros, como 100. Não os confunda com o nível de tarefa. end_time, que é o tempo de conclusão da tarefa como uma string de datas, como "2024-09-12 15:11:40.903".
Indo ao vivo
Quando você move a transcrição de arquivos de áudio para a produção, as seguintes práticas melhoram a qualidade do reconhecimento e estabilidade do sistema.
- Hospedagem de arquivos: Envie arquivos de áudio para um serviço de armazenamento de objetos como OSS e chame a API por URL. Evite uploads de arquivos locais, que são limitados a 100 QPS e não podem ser aumentados.
- A transcrição de áudio longa é assíncrona, e a API de consulta de tarefas é limitada a 20 QPS por padrão. Ajuste um intervalo razoável, como 2 a 5 segundos, para evitar o desencadeamento de limites de taxa. Para estratégias de votação e gerenciamento de tarefas em lote, veja [Gestão de tarefas assíncrona] (/developer-guides/run-and-scale/async-task-management).
- Implemente um mecanismo de repetição robusto. Para tempo de rede ou erros temporários no lado do servidor (5xx), tente novamente com uma estratégia exponencial de retrocesso.
- Para áudio barulhento, pré-processe com uma ferramenta como FFmpeg antes de submetê-la para reconhecimento.
- Escolha o modelo baseado na duração do áudio. Para áudio em 5 minutos, use Qwen3-ASR-Flash. Para áudio mais de 5 minutos, use Qwen-Audio-3.1-ASR-Flash-Filetrans, Fun-ASR, ou Qwen3-ASR-Flash-Filetrans.
Compare modelos.
| Característica | Fun-ASR |
|---|---|
| Linguagens apoiadas | Chinês (Mandarim, Cantonês, Wu, Minnan, Hakka, Gan, Xiang, Jin; também suporta sotaques de Planícies Centrais, Sudoeste, Ji-Lu, Jianghuai, Lan-Yin, Jiao-Liao, Nordeste, Pequim, Hong Kong e Taiwan, incluindo dialetos oficiais de regiões como Henan, Shaanxi, Hubei, Sichuan, Chongqing, Yunnan, Guizhou, Guangdong, Guangxi, Hebei, Tianjin, Shandong, Anhui, Nanjing, Jiangsu, Hangzhou, Gansu e Ningxia), Inglês, japonês, coreano, vietnamita, indonésio, Tailandês, Malay, Filipino, árabe, búlgaro, croata, checo, dinamarquês, holandês, estoniano, Finlandês, grego, hindi, húngaro, irlandês, letão, lituano, maltês, polonês, português, romeno, eslovaco, esloveno, sueco |
| Formatos de áudio suportados | AAC, AVI, FLAC, FLV, M4A, MKV, mov, mp3, mp4, mpeg, ogg, opus, wav, webm, wma, wmv |
| Taxa de amostragem | Qualquer |
| Canais de som | Qualquer |
| Formato de entrada | URLs de arquivos acessíveis publicamente para serem reconhecidos. Até 100 arquivos de áudio são suportados. |
| Tamanho/duração do áudio | Cada arquivo de áudio não deve ser maior que 2 GB e não deve durar mais de 12 horas. |
| Reconhecimento de emoções | Não apoiado. |
| Hora | Apoiado (sempre em) |
| Previsão de pontuação | Apoiado (sempre em) |
| Palavras quentes | Apoiado. A característica de palavra quente é suportada apenas no espaço de trabalho primário e não está disponível em sub-espaços de trabalho. |
| Itn | Apoiado (sempre em) |
| Reconhecimento de voz cantada | Apoiado.fun-asr Apenas) |
| Rejeição de ruído | Apoiado (sempre em) |
| Filtragem sensível de palavras | Suportado (filtros conteúdo doQwenCloud Lista de palavras sensíveis.por padrão) |
| Diarização do presidente da câmara | Suportado (desativado por padrão, pode ser ativado) |
| Filtragem de palavras de preenchimento | Não apoiado. |
| VAD | Apoiado (sempre em) |
| Limitação de taxa (RPS) | API de submissão de trabalho: 10, API de consulta de tarefas: 20 |
| Tipos de conexão | Java/Python SDK, API RESTful |
| -Preços. | International: US$ 0.000035/second |
- Que palavras quentes. A característica de palavra quente é suportada apenas no espaço de trabalho primário e não está disponível em sub-espaços de trabalho. .. Itn Suportado ..
Cantando reconhecimento de voz # # Apoiado #fun-asr Apenas) ..
Rejeição do ruído Suportada .. Filtragem de palavras sensíveis Suportado (filtros de conteúdo doQwenCloud "Lista de palavras sensíveis" (https://dashscope.oss-cn-beijing.aliyuncs.com/samples/audio/paraformer/%E7%99%BE%E7%82%BC%E6%95%8F%E6%84%9F%E8%AF%8D%E5%88%97%E8%A1%A8_20230716.words.txt) por padrão) Diarização do falante .. Suportado (por padrão, pode ser ativado) .. Não é suportado .. VAD, sempre apoiado. .. Rate limitant (RPS) ..Job submission API: 10, Tarefa consulta API: 20 .. ** Tipos de conexão** ** DashScope: Java/Python SDK, API de descanso .. Tradução:$0.000035 (≈ R$ 0,000176*)-Segunda. ..
Referência da API
Qwen-Audio-3.x-ASR-Flash-Filetrans/Fun-ASR
- [A API RESTRUENTE] (/api-reference/speech-recognition/fun-asr-recording/restful-api)
- [Fun-ASR-Flash (síncrono)](/api-reference/speech-recognition/fun-asr-recording/restful-api#fun-asr-flash-synchronous)
- [Python SDK] (/api-reference/speech-recognition/fun-asr-recording/python-sdk)
- [Java SDK] (/api-reference/speech-recognition/fun-asr-recording/java-sdk)
- [Android SDK] (/api-reference/speech-recognition/fun-asr-recording/android-sdk)
- [IOS SDK] (/api-reference/speech-recognition/fun-asr-recording/ios-sdk)
- [HarmonyOS SDK] (/api-reference/speech-recognition/fun-asr-recording/harmonyos-sdk)
Qwen-ASR
[Qwen-ASR Referência da API (/api-reference/speech-recognition/qwen-asr/openai)
Qwen-Omni
- [Audio e vídeo de compreensão de arquivos] (/developer-guides/speech/multimodal-speech)
- [Fala-para-fala modelos] (/developer-guides/speech/s2s-models)
FAQ
Qwen-Audio-3.x-ASR-Flash-Filetrans/Fun-ASR
#### Como posso melhorar a precisão do reconhecimento?
Vários fatores afetam a precisão. Revise cada um e aplique a otimização correspondente.
Fatores-chave:
1. Qualidade do som: qualidade do dispositivo de gravação, taxa de amostra e ruído ambiente afetam diretamente a clareza. Entrada de áudio de alta qualidade é essencial.
2. Variações na velocidade de fala, sotaque e dialeto aumentam a dificuldade de reconhecimento, especialmente para dialetos raros ou sotaques pesados.
3. Linguagem e vocabulário: línguas mistas, termos técnicos, ou gírias aumentam a dificuldade de reconhecimento. Configure palavras para melhorar a precisão para termos específicos de domínio.
4. O contexto insuficiente pode causar ambiguidade semântica, especialmente em situações em que o contexto circundante é necessário para o reconhecimento correto.
Métodos de otimização:
1. Otimize a qualidade de áudio, use microfones de alto desempenho na taxa de amostragem recomendada. Minimize o ruído ambiente e eco.
2. Para áudio com sotaques fortes ou dialetos, selecione um modelo que suporte esses dialetos específicos.
3. Configure palavras importantes, defina palavras importantes para termos técnicos, substantivos adequados e outras palavras específicas. Para mais informações, veja [Perstomize palavras quentes] (/developer-guides/speech/improve-recognition-accuracy).
4. Evite dividir áudio em clipes excessivamente curtos.
Qwen-ASR
#### P: Como posso fornecer uma URL de áudio acessível publicamente para a API?
Recomendamos usar o Serviço de Armazenamento de Objetos (OSS), que fornece armazenamento altamente disponível e confiável e facilmente gera URLs públicas.
** Verifique se sua URL é acessível publicamente:** Abra a URL em um navegador ou use o curl para garantir que o arquivo de áudio seja baixado ou reproduzido com sucesso (código de status 200 do HTTP).
#### Como posso verificar se meu formato de áudio atende às exigências?
Use a ferramenta de código aberto.https://ffmpeg.org/ffprobe.html) para obter rapidamente informações detalhadas de áudio:
```bash
# 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
```
#### Como faço para processar áudio para atender os requisitos do modelo?
Use a ferramenta de código aberto [FFmpeg] (https://ffmpeg.en.lo4d.com/download) para cortar ou converter formatos de áudio:
- Extrair um segmento de um longo arquivo de áudio
```bash
# -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
```
- Conversão de Formatos
Por exemplo, converta qualquer áudio para 16 kHz, 16 bits, mono WAV.
```bash
# -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
```
Qwen-Omni
Qwen-Omni interpreta todo o áudio, não apenas o discurso. Música, digitação ou ruído ambiente podem produzir descrições em vez de transcrição. Para áudio misto, pré-processo com DAV para isolar a fala, ou adicionar uma instrução rápida do sistema: "Transcreva apenas a fala humana. Ignore sons não falantes."
#### Quando devo usar Qwen-Omni Em vez de modelos dedicados de ASR?
Use Qwen-Omni Quando:
1. Precisa transcrever áudio com vocabulário especializado. Descreva seu domínio no sistema.
2. Tradução: want Para fornecer contexto de conversação para uma precisão melhor.
3. Você precisa processar áudio ao lado de imagens ou vídeo.
4. Você prefere usar a API compatível com o OpenAI.
Use modelos dedicados de ASR (Fun-ASR, Qwen-ASR) quando:
1. Modelos dedicados de RSA têm latência menor por pedido.
2. Você precisa de suporte para palavras quentes (apenas disponível em Fun-ASR).
3. Você precisa identificar diferentes alto-falantes (apenas disponíveis em Fun-ASR).
4. ** Longos arquivos de áudio**: Fun-ASR Suporta até 12 horas de áudio.
#### Como melhoro a precisão de transcrição com Qwen-Omni?
Use o sistema para fornecer contexto:
```python
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."}]}
]
```