Tradução de arquivos de áudio e vídeo

Tradução de 18 idiomas

Detalhes do modelo.

qwen3-livetranslate-flash Atualmente tem as mesmas capacidades que qwen3-livetranslate-flash-2025-12-01.

Começando.

Pré-requisitos

1. [Pegue uma chave API] (/api-reference/preparation/api-key).
2. [Configurado como uma variável de ambiente] (/api-reference/preparation/export-api-key-env).
3. Se você usar o SDK OpenAI, [instale o SDK] (/api-reference/preparation/install-sdk).

Todos os exemplos usam a API de streaming compatível com OpenAI com translation_options para definir a fonte e as línguas alvo. A entrada padrão é áudio. Para traduzir um arquivo de vídeo, descomente o bloco de entrada de vídeo em cada exemplo.

Especificando source_lang Melhora a precisão da tradução. Omitir permite detecção automática de linguagem.

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",
)

# --- Audio input ---
messages = [
  {
    "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",
          "format": "wav",
        },
      }
    ],
  }
]

# --- Video input (uncomment to use) ---
# messages = [
#     {
#         "role": "user",
#         "content": [
#             {
#                 "type": "video_url",
#                 "video_url": {
#                     "url": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241115/cqqkru/1.mp4"
#                 },
#             }
#         ],
#     },
# ]

completion = client.chat.completions.create(
  model="qwen3-livetranslate-flash",
  messages=messages,
  modalities=["text", "audio"],
  audio={"voice": "Cherry", "format": "wav"},
  stream=True,
  stream_options={"include_usage": True},
  # translation_options is not a standard OpenAI parameter; pass it through extra_body
  extra_body={"translation_options": {"source_lang": "zh", "target_lang": "en"}},
)

for chunk in completion:
  print(chunk)
```

Node.js

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
});

// --- Audio input ---
const messages = [
  {
    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",
          format: "wav",
        },
      },
    ],
  },
];

// --- Video input (uncomment to use) ---
// const messages = [
//     {
//         role: "user",
//         content: [
//             {
//                 type: "video_url",
//                 video_url: {
//                     url: "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20241115/cqqkru/1.mp4",
//                 },
//             },
//         ],
//     },
// ];

async function main() {
  const completion = await client.chat.completions.create({
    model: "qwen3-livetranslate-flash",
    messages: messages,
    modalities: ["text", "audio"],
    audio: { voice: "Cherry", format: "wav" },
    stream: true,
    stream_options: { include_usage: true },
    translation_options: { source_lang: "zh", target_lang: "en" },
  });

  for await (const chunk of completion) {
    console.log(JSON.stringify(chunk));
  }
}

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-livetranslate-flash",
  "messages": [
    {
      "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",
            "format": "wav"
          }
        }
      ]
    }
  ],
  "modalities": ["text", "audio"],
  "audio": {
    "voice": "Cherry",
    "format": "wav"
  },
  "stream": true,
  "stream_options": {
    "include_usage": true
  },
  "translation_options": {
    "source_lang": "zh",
    "target_lang": "en"
  }
}'
```

Esses exemplos usam um URL de arquivo público.

Envie um arquivo local codificado pela Base64.

Para traduzir um arquivo de áudio local, leia-o e codifique-o como Base64. Passe os dados como URI de dados com o formato data:audio/<format>;base64,<base64_data> (por exemplo, data:audio/wav;base64,UklGRiQAAABXQVZFZm10...).

Formatos de áudio suportados: WAV, MP3, FLAC, AAC, OGG, OPUS, M4A, WMA, AMR. Taxa de amostragem: 8kHz-48kHz.

Python

```python
import os
import base64
from openai import OpenAI

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)

# Read and encode a local audio file
with open("local_audio.wav", "rb") as f:
  audio_base64 = base64.b64encode(f.read()).decode("utf-8")

completion = client.chat.completions.create(
  model="qwen3-livetranslate-flash",
  messages=[
    {
      "role": "user",
      "content": [
        {
          "type": "input_audio",
          "input_audio": {
            "data": f"data:audio/wav;base64,{audio_base64}",
            "format": "wav",
          },
        }
      ],
    }
  ],
  modalities=["text", "audio"],
  audio={"voice": "Cherry", "format": "wav"},
  stream=True,
  stream_options={"include_usage": True},
  extra_body={"translation_options": {"source_lang": "zh", "target_lang": "en"}},
)

for chunk in completion:
  print(chunk)
```

Node.js

```javascript
import OpenAI from "openai";
import { readFileSync } from "node:fs";

const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
});

// Read and encode a local audio file
const audioBase64 = readFileSync("local_audio.wav").toString("base64");

async function main() {
  const completion = await client.chat.completions.create({
    model: "qwen3-livetranslate-flash",
    messages: [
      {
        role: "user",
        content: [
          {
            type: "input_audio",
            input_audio: {
              data: `data:audio/wav;base64,${audioBase64}`,
              format: "wav",
            },
          },
        ],
      },
    ],
    modalities: ["text", "audio"],
    audio: { voice: "Cherry", format: "wav" },
    stream: true,
    stream_options: { include_usage: true },
    translation_options: { source_lang: "zh", target_lang: "en" },
  });

  for await (const chunk of completion) {
    console.log(JSON.stringify(chunk));
  }
}

main();
```

curl

```bash
# Encode the local audio file as Base64
AUDIO_BASE64=$(base64 < local_audio.wav)

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-livetranslate-flash",
  "messages": [
    {
      "role": "user",
      "content": [
        {
          "type": "input_audio",
          "input_audio": {
            "data": "data:audio/wav;base64,'"$AUDIO_BASE64"'",
            "format": "wav"
          }
        }
      ]
    }
  ],
  "modalities": ["text", "audio"],
  "audio": {
    "voice": "Cherry",
    "format": "wav"
  },
  "stream": true,
  "stream_options": {
    "include_usage": true
  },
  "translation_options": {
    "source_lang": "zh",
    "target_lang": "en"
  }
}'
```

Requisito parâmetros.

Entrada

O messages O array deve conter exatamente uma mensagem com role - Pronto para... user. O content campo mantém o áudio ou vídeo para traduzir:

• Audio: Set type para input_audio. Fornecer o URL do arquivo ou um URI de dados (por exemplo, data:audio/wav;base64,<base64_data>) em input_audio.data, e especificar o formato (por exemplo, wav) em input_audio.format. Veja [Enviar um arquivo local codificado pela Base64] (#send-a-base64-encoded-local-file) para detalhes.
• Vídeo:Set type para video_url. Fornecer o URL do arquivo em video_url.url.

Opções de tradução

Especifique a fonte e as línguas alvo na translation_options parâmetro:

"translation_options": {"source_lang": "zh", "target_lang": "en"}

No Python SDK, translation_options Não é um parâmetro padrão do OpenAI. Passe por ela. extra_body:

extra_body={"translation_options": {"source_lang": "zh", "target_lang": "en"}}

Modo de saída

Controle o formato de saída com o modalities parâmetro:

Quando a saída incluir áudio, defina a voz no audio parâmetro. Veja [Vozes Suportadas] (#supported-voices) para opções disponíveis.

Restrições

• O modelo lida com uma tradução por pedido. Conversas multi-volta não são suportadas.
• Sem mensagem do sistema system O papel não é suportado.
• Ambos os lados estão em movimento. stream: true e stream: false são apoiados.
• ** Formato de áudio de saída**: Somente wav é suportado para saída de áudio.
• Amostragem padrão: Os parâmetros de amostragem padrão (temperature, top_p, top_k, presence_penalty, repetition_penalty) são sintonizados para a precisão da tradução. Alterá-los pode reduzir a qualidade da saída.

Analisar a resposta.

Cada transmissão chunk O objeto contém:

• ** Texto**: chunk.choices[0].delta.content
• Audio: chunk.choices[0].delta.audio["data"] (Base64-codificado, taxa de amostra de 24 kHz)

Salve áudio em um arquivo

Concatene todos os fragmentos de áudio Base64 do fluxo, então decodifique e salve o resultado depois que o fluxo terminar.

Python

```python
import os
from openai import OpenAI
import base64
import numpy as np
import soundfile as sf

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)

messages = [
  {
    "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",
          "format": "wav",
        },
      }
    ],
  }
]

completion = client.chat.completions.create(
  model="qwen3-livetranslate-flash",
  messages=messages,
  modalities=["text", "audio"],
  audio={"voice": "Cherry", "format": "wav"},
  stream=True,
  stream_options={"include_usage": True},
  extra_body={"translation_options": {"source_lang": "zh", "target_lang": "en"}},
)

# Concatenate Base64 fragments, then decode after the stream completes
audio_string = ""
for chunk in completion:
  if chunk.choices:
    if hasattr(chunk.choices[0].delta, "audio"):
      try:
        audio_string += chunk.choices[0].delta.audio["data"]
      except Exception as e:
        print(chunk.choices[0].delta.audio["transcript"])
  else:
    print(chunk.usage)

wav_bytes = base64.b64decode(audio_string)
audio_np = np.frombuffer(wav_bytes, dtype=np.int16)
sf.write("output.wav", audio_np, samplerate=24000)
```

Node.js

```javascript
import OpenAI from "openai";
import { createWriteStream } from "node:fs";
import { Writer } from "wav";

const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
});

const messages = [
  {
    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",
          format: "wav",
        },
      },
    ],
  },
];

const completion = await client.chat.completions.create({
  model: "qwen3-livetranslate-flash",
  messages: messages,
  modalities: ["text", "audio"],
  audio: { voice: "Cherry", format: "wav" },
  stream: true,
  stream_options: { include_usage: true },
  translation_options: { source_lang: "zh", target_lang: "en" },
});

// Concatenate Base64 fragments, then decode after the stream completes
let audioString = "";
for await (const chunk of completion) {
  if (Array.isArray(chunk.choices) && chunk.choices.length > 0) {
    if (chunk.choices[0].delta.audio?.data) {
      audioString += chunk.choices[0].delta.audio.data;
    }
  } else {
    console.log(chunk.usage);
  }
}

// Save as WAV file
async function saveAudio(base64Data, outputPath) {
  const wavBuffer = Buffer.from(base64Data, "base64");
  const writer = new Writer({
    sampleRate: 24000,
    channels: 1,
    bitDepth: 16,
  });
  const outputStream = createWriteStream(outputPath);
  writer.pipe(outputStream);
  writer.write(wavBuffer);
  writer.end();
  await new Promise((resolve, reject) => {
    outputStream.on("finish", resolve);
    outputStream.on("error", reject);
  });
  console.log(`Audio saved to ${outputPath}`);
}

saveAudio(audioString, "output.wav");
```

Reprodução em tempo real.

Decodificar cada fragmento Base64 como ele chega e tocá-lo diretamente. Essa abordagem requer bibliotecas de áudio específicas da plataforma.

Python

 Instalar `pyaudio`  Primeiro:

Centos # sudo yum install -y portaudio portaudio-devel && pip install pyaudio |

? Janelas ? python -m pip install pyaudio |

```python
import os
from openai import OpenAI
import base64
import numpy as np
import pyaudio
import time

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
)

messages = [
  {
    "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",
          "format": "wav",
        },
      }
    ],
  }
]

completion = client.chat.completions.create(
  model="qwen3-livetranslate-flash",
  messages=messages,
  modalities=["text", "audio"],
  audio={"voice": "Cherry", "format": "wav"},
  stream=True,
  stream_options={"include_usage": True},
  extra_body={"translation_options": {"source_lang": "zh", "target_lang": "en"}},
)

# Initialize PyAudio for real-time playback
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)

for chunk in completion:
  if chunk.choices:
    if hasattr(chunk.choices[0].delta, "audio"):
      try:
        audio_data = chunk.choices[0].delta.audio["data"]
        wav_bytes = base64.b64decode(audio_data)
        audio_np = np.frombuffer(wav_bytes, dtype=np.int16)
        stream.write(audio_np.tobytes())
      except Exception as e:
        print(chunk.choices[0].delta.audio["transcript"])

time.sleep(0.8)
stream.stop_stream()
stream.close()
p.terminate()
```

Node.js

 Instale dependências primeiro:

```javascript
import OpenAI from "openai";
import Speaker from "speaker";

const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY,
  baseURL: "https://maas.qwencloudapi.com/compatible-mode/v1",
});

const messages = [
  {
    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",
          format: "wav",
        },
      },
    ],
  },
];

const completion = await client.chat.completions.create({
  model: "qwen3-livetranslate-flash",
  messages: messages,
  modalities: ["text", "audio"],
  audio: { voice: "Cherry", format: "wav" },
  stream: true,
  stream_options: { include_usage: true },
  translation_options: { source_lang: "zh", target_lang: "en" },
});

// Stream audio to speaker in real time
const speaker = new Speaker({
  sampleRate: 24000,
  channels: 1,
  bitDepth: 16,
  signed: true,
});

for await (const chunk of completion) {
  if (Array.isArray(chunk.choices) && chunk.choices.length > 0) {
    if (chunk.choices[0].delta.audio?.data) {
      const pcmBuffer = Buffer.from(chunk.choices[0].delta.audio.data, "base64");
      speaker.write(pcmBuffer);
    }
  } else {
    console.log(chunk.usage);
  }
}

speaker.on("finish", () => console.log("Playback complete"));
speaker.end();
```

Contagem

Audio

O consumo de áudio depende das características de áudio (como a taxa de amostragem). Para ver o uso real do símbolo, definir `stream_options.include_usage` para `true` e verificar o `usage`  campo na resposta.



   Áudio menor que 1 segundo é cobrado como 1 segundo.

Video

O consumo de fichas de vídeo tem dois componentes:

- O consumo de token depende de características de áudio (como taxa de amostra).  Áudio menor que 1 segundo é cobrado como 1 segundo.
-  Calculado baseado na contagem de quadros e resolução. A fórmula é:

```text
video_tokens = ceil(frame_count / 2) x (height / 32) x (width / 32) + 2
```

 Onde:

- As imagens são amostradas em 2 FPS, presas ao alcance \[4, 128].
-  Altura e largura são ajustadas para múltiplos de 32 pixels e escalados dinamicamente para caber dentro do limite total de pixels.

Python script to calculate video tokens

  ```python
  # Install: pip install opencv-python
  import math
  import cv2

  FRAME_FACTOR = 2
  IMAGE_FACTOR = 32
  MAX_RATIO = 200
  VIDEO_MIN_PIXELS = 128 * 32 * 32
  VIDEO_MAX_PIXELS = 768 * 32 * 32
  FPS = 2
  FPS_MIN_FRAMES = 4
  FPS_MAX_FRAMES = 128
  VIDEO_TOTAL_PIXELS = 16384 * 32 * 32

  def round_by_factor(number, factor):
    return round(number / factor) * factor

  def ceil_by_factor(number, factor):
    return math.ceil(number / factor) * factor

  def floor_by_factor(number, factor):
    return math.floor(number / factor) * factor

  def get_video(video_path):
    cap = cv2.VideoCapture(video_path)
    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    video_fps = cap.get(cv2.CAP_PROP_FPS)
    cap.release()
    return frame_height, frame_width, total_frames, video_fps

  def smart_nframes(total_frames, video_fps):
    min_frames = ceil_by_factor(FPS_MIN_FRAMES, FRAME_FACTOR)
    max_frames = floor_by_factor(min(FPS_MAX_FRAMES, total_frames), FRAME_FACTOR)
    duration = total_frames / video_fps if video_fps != 0 else 0
    if duration - int(duration) > (1 / FPS):
      total_frames = math.ceil(duration * video_fps)
    else:
      total_frames = math.ceil(int(duration) * video_fps)
    nframes = total_frames / video_fps * FPS
    nframes = int(min(min(max(nframes, min_frames), max_frames), total_frames))
    if not (FRAME_FACTOR <= nframes <= total_frames):
      raise ValueError(f"nframes should in interval [{FRAME_FACTOR}, {total_frames}], but got {nframes}.")
    return nframes

  def smart_resize(height, width, nframes, factor=IMAGE_FACTOR):
    min_pixels = VIDEO_MIN_PIXELS
    total_pixels = VIDEO_TOTAL_PIXELS
    max_pixels = max(min(VIDEO_MAX_PIXELS, total_pixels / nframes * FRAME_FACTOR), int(min_pixels * 1.05))
    if max(height, width) / min(height, width) > MAX_RATIO:
      raise ValueError(f"absolute aspect ratio must be smaller than {MAX_RATIO}, got {max(height, width) / min(height, width)}")
    h_bar = max(factor, round_by_factor(height, factor))
    w_bar = max(factor, round_by_factor(width, factor))
    if h_bar * w_bar > max_pixels:
      beta = math.sqrt((height * width) / max_pixels)
      h_bar = floor_by_factor(height / beta, factor)
      w_bar = floor_by_factor(width / beta, factor)
    elif h_bar * w_bar < min_pixels:
      beta = math.sqrt(min_pixels / (height * width))
      h_bar = ceil_by_factor(height * beta, factor)
      w_bar = ceil_by_factor(width * beta, factor)
    return h_bar, w_bar

  def video_token_calculate(video_path):
    height, width, total_frames, video_fps = get_video(video_path)
    nframes = smart_nframes(total_frames, video_fps)
    resized_height, resized_width = smart_resize(height, width, nframes)
    video_token = int(math.ceil(nframes / FPS) * resized_height / 32 * resized_width / 32)
    video_token += 2
    return video_token

  if __name__ == "__main__":
    video_path = "spring_mountain.mp4"  # Replace with your video path
    video_token = video_token_calculate(video_path)
    print("video_tokens:", video_token)
  ```

Para preços de fichas, veja [Escolha modelos] (/developer-guides/getting-started/model-selection).

Linguagens apoiadas

Os seguintes códigos de linguagem podem ser usados para línguas de origem e alvo. Algumas línguas de destino suportam apenas texto.

Vozes apoiadas

Defina o voice parâmetro quando a saída inclui áudio sintetizado. Para os valores disponíveis, veja [lista de voz Omni-modal] (/developer-guides/speech/omni-voice-list).

Alternativa: Uso Qwen-Omni

Você também pode usar Qwen-Omni (qwen3-omni-flash) com um pedido de tradução para traduzir arquivos de áudio e vídeo.

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": "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": "Translate this audio from English to Chinese."}
  ]
  }],
  modalities=["text"],
  stream=True,
)

for chunk in completion:
  if chunk.choices and chunk.choices[0].delta.content:
    print(chunk.choices[0].delta.content, end="")

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": "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": "Translate this audio from English to Chinese."}
    ]
  }],
  "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).

FAQ

Quando eu insiro um arquivo de vídeo, que conteúdo é traduzido?

O modelo traduz a faixa de áudio do vídeo. Informações visuais servem como contexto para melhorar a precisão da tradução.

Por exemplo, se o áudio diz "Esta é uma máscara":

• Quando o vídeo mostra uma máscara médica, o modelo traduz como "Esta é uma máscara médica".
• Quando o vídeo mostra uma máscara de máscara, o modelo traduz como "Esta é uma máscara de máscara".

Referência da API

Para detalhes completos do parâmetro de entrada e saída, veja referência de tradução de áudio e vídeo API.