Source: https://ailoot.ai/models/pt-pt/qwen-audio-3-0-realtime-plus/
Canonical: https://ailoot.ai/models/pt-pt/qwen-audio-3-0-realtime-plus/
Language: pt-pt

# qwen-audio-3.0-realtime-plus

[Markdown](https://ailoot.ai/models/pt-pt/qwen-audio-3-0-realtime-plus/index.md) · [JSON](https://ailoot.ai/models/pt-pt/qwen-audio-3-0-realtime-plus/facts.json)

## [qwen-audio-3.0-realtime-plus](https://ailoot.ai/models/pt-pt/qwen-audio-3-0-realtime-plus/)

Modelo de diálogo de voz em tempo real que recebe fala e texto e responde por voz ou texto. Concebido para um ritmo natural de conversa e para interação com ferramentas.

- [**Ailoot · Voz em tempo real** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` `qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/pt-pt/qwen-audio-3-0-realtime-plus/#method-0)

Sobre o modelo

Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.

Qwen-Audio-3.0-Realtime-Plus é um modelo da Alibaba para diálogo de voz em tempo real. Recebe fala e texto, responde com áudio e texto e suporta uma conversa bidirecional com uma troca natural de intervenções. O som pode ser enviado e recebido por partes, permitindo que a interação evolua durante a conversa.

#### Quando o interlocutor termina a ideia

Estão previstas várias formas de determinar os limites de uma intervenção: pela atividade sonora, pela conclusão semântica e por controlo explícito. No fabricante, o modo é escolhido antes de enviar o primeiro áudio; para o alterar depois de começar a conversa, é necessária uma nova ligação. O suporte deste controlo depende do método selecionado. O modo semântico considera pausas e hesitações: uma breve dúvida não significa necessariamente que o utilizador terminou a ideia. Uma nova intervenção do utilizador pode interromper a resposta em formação, permitindo continuar a conversa com a intervenção seguinte em conta. No modo semântico, o reconhecimento pode ser orientado por uma amostra de fala do interlocutor escolhido, para reduzir a influência de outras vozes e do ruído de fundo.

As instruções definem o papel do assistente e o estilo de comunicação. A expressão vocal pode considerar o tom, o ritmo e a emoção; a versão 3.0 prevê cinco vozes de sistema e vozes baseadas numa amostra de fala. O modelo suporta 11 línguas, incluindo russo, bem como as variantes dialetais chinesas indicadas pelo fabricante. No fabricante, a voz é definida na primeira atualização das configurações da sessão; o envio posterior de outra voz na mesma conversa é ignorado. Estas configurações exigem suporte do meio de acesso escolhido.

#### Ferramentas e histórico da conversa

É suportada a chamada de funções. O modelo formula a ação necessária, a aplicação ligada executa-a e devolve o resultado ao diálogo. Isto permite construir a conversa em torno de dados factuais e continuá-la após a operação realizada. Um assistente de voz pode apoiar-se nos resultados das ferramentas, mantendo o contexto da conversa. As capacidades do fabricante incluem também pesquisa na Web integrada, se esta for disponibilizada pelo método escolhido. A pesquisa na Web e as chamadas de funções não podem ser ativadas em simultâneo na mesma sessão.

Por predefinição, o histórico contém 20 turnos de conversa, estando previsto um intervalo entre um e 50. Para o áudio acumulado, existe um limite de 300 segundos; as partes mais antigas do histórico são eliminadas quando os limites são ultrapassados. Isto é diferente da duração de uma intervenção individual: o histórico determina que material anterior continua disponível quando o diálogo prossegue.

#### Contexto textual e som

O contexto formal é de 40 960 tokens. O comprimento máximo da entrada é de 16 384 tokens e o da saída é de 8192; os mesmos limites de entrada e saída são indicados para o modo de raciocínio, com um limite separado de 1024 tokens para a cadeia de raciocínio.

Para áudio em streaming, está previsto PCM de canal único com representação de 16 bits: 16 kHz na entrada e 24 kHz na saída. Os dados textuais e de áudio pertencem à mesma conversa. Não estão anunciadas entrada visual nem geração de imagens para este modelo específico; a sua especialização é fala, texto e interação por voz.

**Ailoot · Voz em tempo real** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` `qwen-audio-3.0-realtime-plus`

[`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/pt-pt/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime)

Alibaba /`qwen-audio-3.0-realtime-plus`

### Introdução

Modelo de diálogo de voz em tempo real que recebe fala e texto e responde por voz ou texto. Concebido para um ritmo natural de conversa e para interação com ferramentas.

Entradas aceites

Texto · Áudio

Resultados

Texto · Áudio

### Disponível no Ailoot · entradas e métodos

**Ailoot · Voz em tempo real** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus`

Entrada

`text`, `audio`

Saída

`text`, `audio`

Formato de saída

eventos da sessão

| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`query.model` | Tipo`string` | RequisitoObrigatório | Valores e limites qwen-audio-3.0-realtime-plus | Predefinição— |
| Campo`session.input_audio_format` | Tipo`string` | RequisitoOpcional | Valores e limites pcm16, pcm | Predefinição— |
| Campo`session.output_audio_format` | Tipo`string` | RequisitoOpcional | Valores e limites pcm16, pcm | Predefinição— |
| Campo`session.instructions` | Tipo`string` | RequisitoOpcional | Valores e limites O limite aplica-se a: política de sessão selecionada | Predefinição— |
| Campo`session.max_history_turns` | Tipo`integer` | RequisitoOpcional | Valores e limites Mínimo: 1 O limite aplica-se a: política de sessão selecionada | Predefinição— |
| Campo`input_audio_buffer.append.audio` | Tipo`base64_string` | RequisitoObrigatório | Valores e limites Conteúdo de entrada: PCM16 mono; entrada de 16 kHz, saída de 24 kHz; comprimento em bytes não vazio e par | Predefinição— |

Combinações de materiais de entrada

**realtime\_text\_audio**

Parâmetros e ciclo de vida do método

| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`material_types` | Contratotext, audio |
| Parâmetro`required` | Contratonull |
| Parâmetro`optional_controls` | Contratonull |
| Parâmetro`content_type` | ContratoWebSocket |

Ciclo de vida: `exact retained published method`

As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.

### Tarifários

#### Tarifas dos métodos Ailoot

Entrada

0,0008 US$ */ 1K*

Saída

0,0064 US$ */ 1K*

Entrada

0,0048 US$ *por minuto de áudio*

Saída

0,018 US$ *por minuto de áudio de saída*

O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)

### Exemplos de pedidos

#### Ailoot · Voz em tempo real

Python WebSocket · textoPython WebSocket · áudio

```python
# Install the documented client once: python3 -m pip install websockets
import base64, json, os, time, wave
from pathlib import Path
from websockets.sync.client import connect

key = os.environ.get("AILOOT_API_KEY", "")
if not key.strip():
    raise SystemExit("Set your AILOOT_API_KEY before connecting")
file = Path(os.environ.get("AILOOT_TEXT_FILE", ""))
if not file.is_file(): raise SystemExit("Set AILOOT_TEXT_FILE to your actual UTF-8 material")
material = file.read_text(encoding="utf-8")
if not material.strip(): raise SystemExit("Text material must not be empty")
out = Path("realtime-results")
out.mkdir(exist_ok=True)
audio, texts, complete = {}, {}, []
current_response = None
pending = False
deadline = time.monotonic() + 570  # Local client bound; lower server/session limits still apply.

def receive(ws, log):
    global current_response, pending
    left = deadline - time.monotonic()
    if left <= 0:
        raise TimeoutError("Client session limit; preserve IDs and partial results, do not replay")
    event = json.loads(ws.recv(timeout=min(60, left)))
    log.write(json.dumps(event, ensure_ascii=False) + "\n")
    log.flush()
    kind = event.get("type")
    if kind == "error":
        raise RuntimeError(json.dumps(event, ensure_ascii=False))
    if kind == "response.created":
        current_response = event["response"]["id"]
    if kind in {"response.audio.delta", "response.output_audio.delta", "response.text.delta", "response.output_text.delta", "response.audio_transcript.delta", "response.output_audio_transcript.delta", "response.text.done", "response.audio_transcript.done"}:
        identity = (event["response_id"], event["item_id"], event["output_index"], event["content_index"])
        if kind in {"response.audio.delta", "response.output_audio.delta"}:
            raw = base64.b64decode(event["delta"], validate=True)
            if len(raw) % 2: raise ValueError("Output PCM16 chunk must have an even byte length")
            audio.setdefault(identity, bytearray()).extend(raw)
        elif kind.endswith(".done"):
            texts[identity] = event.get("text", event.get("transcript", ""))
        else:
            texts[identity] = texts.get(identity, "") + event["delta"]
            print(event["delta"], end="", flush=True)
    if kind == "response.done":
        response = event["response"]
        complete.append(response)
        if current_response is None: current_response = response["id"]
        if response["id"] == current_response: pending = False
    return event

def wait_for(ws, log, kind):
    while True:
        event = receive(ws, log)
        if event.get("type") == kind: return event

def send(ws, event):
    ws.send(json.dumps(event, ensure_ascii=False))

try:
    # One exact model query; no reconnect/retry loop and no provider credentials.
    with connect("wss://api.ailoot.ai/v1/realtime?model=qwen-audio-3.0-realtime-plus", additional_headers={"Authorization": "Bearer " + key}) as ws:
        with (out / "events.jsonl").open("w", encoding="utf-8") as log:
            wait_for(ws, log, "session.created")
            send(ws, {"type":"session.update", "session":{"modalities":["audio","text"], "input_audio_format":"pcm", "output_audio_format":"pcm", "turn_detection":None}})
            wait_for(ws, log, "session.updated")
            send(ws, {"type":"conversation.item.create", "item":{"type":"message", "role":"user", "content":[{"type":"input_text", "text":material}]}})
            send(ws, {"type":"response.create"})
            pending = True
            try:
                while pending: receive(ws, log)
            except KeyboardInterrupt:
                # Cancel the actual current inference, then preserve its returned status.
                send(ws, {"type":"response.cancel"})
                while pending: receive(ws, log)
    if not complete or complete[-1].get("status") != "completed":
        raise RuntimeError("Response did not complete normally; inspect saved events and status")
finally:
    manifest = {"responses":complete, "parts":[]}
    for number, identity in enumerate(dict.fromkeys(list(audio) + list(texts))):
        record = {"response_id":identity[0], "item_id":identity[1], "output_index":identity[2], "content_index":identity[3]}
        if identity in audio:
            raw = bytes(audio[identity])
            pcm_file = out / ("audio-" + str(number) + ".pcm")
            wav_file = out / ("audio-" + str(number) + ".wav")
            pcm_file.write_bytes(raw)
            with wave.open(str(wav_file), "wb") as wav:
                wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(24000); wav.writeframes(raw)
            record.update({"pcm":str(pcm_file), "wav":str(wav_file), "sample_rate_hz":24000})
        if identity in texts:
            text_file = out / ("text-" + str(number) + ".txt")
            text_file.write_text(texts[identity], encoding="utf-8")
            record["text"] = str(text_file)
        manifest["parts"].append(record)
    (out / "results.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    print("\nSaved every received event and result in", out)
```

```python
# Install the documented client once: python3 -m pip install websockets
import base64, json, os, time, wave
from pathlib import Path
from websockets.sync.client import connect

key = os.environ.get("AILOOT_API_KEY", "")
if not key.strip():
    raise SystemExit("Set your AILOOT_API_KEY before connecting")
file = Path(os.environ.get("AILOOT_AUDIO_FILE", ""))
if not file.is_file(): raise SystemExit("Set AILOOT_AUDIO_FILE to your raw PCM16 mono 16-kHz recording")
material = file.read_bytes()
if not material or len(material) % 2 or material.startswith(b"RIFF"):
    raise SystemExit("Use nonempty signed little-endian PCM16 mono 16-kHz bytes, not a WAV header")
out = Path("realtime-results")
out.mkdir(exist_ok=True)
audio, texts, complete = {}, {}, []
current_response = None
pending = False
deadline = time.monotonic() + 570  # Local client bound; lower server/session limits still apply.

def receive(ws, log):
    global current_response, pending
    left = deadline - time.monotonic()
    if left <= 0:
        raise TimeoutError("Client session limit; preserve IDs and partial results, do not replay")
    event = json.loads(ws.recv(timeout=min(60, left)))
    log.write(json.dumps(event, ensure_ascii=False) + "\n")
    log.flush()
    kind = event.get("type")
    if kind == "error":
        raise RuntimeError(json.dumps(event, ensure_ascii=False))
    if kind == "response.created":
        current_response = event["response"]["id"]
    if kind in {"response.audio.delta", "response.output_audio.delta", "response.text.delta", "response.output_text.delta", "response.audio_transcript.delta", "response.output_audio_transcript.delta", "response.text.done", "response.audio_transcript.done"}:
        identity = (event["response_id"], event["item_id"], event["output_index"], event["content_index"])
        if kind in {"response.audio.delta", "response.output_audio.delta"}:
            raw = base64.b64decode(event["delta"], validate=True)
            if len(raw) % 2: raise ValueError("Output PCM16 chunk must have an even byte length")
            audio.setdefault(identity, bytearray()).extend(raw)
        elif kind.endswith(".done"):
            texts[identity] = event.get("text", event.get("transcript", ""))
        else:
            texts[identity] = texts.get(identity, "") + event["delta"]
            print(event["delta"], end="", flush=True)
    if kind == "response.done":
        response = event["response"]
        complete.append(response)
        if current_response is None: current_response = response["id"]
        if response["id"] == current_response: pending = False
    return event

def wait_for(ws, log, kind):
    while True:
        event = receive(ws, log)
        if event.get("type") == kind: return event

def send(ws, event):
    ws.send(json.dumps(event, ensure_ascii=False))

try:
    # One exact model query; no reconnect/retry loop and no provider credentials.
    with connect("wss://api.ailoot.ai/v1/realtime?model=qwen-audio-3.0-realtime-plus", additional_headers={"Authorization": "Bearer " + key}) as ws:
        with (out / "events.jsonl").open("w", encoding="utf-8") as log:
            wait_for(ws, log, "session.created")
            send(ws, {"type":"session.update", "session":{"modalities":["audio","text"], "input_audio_format":"pcm", "output_audio_format":"pcm", "turn_detection":None}})
            wait_for(ws, log, "session.updated")
            for offset in range(0, len(material), 640):
                send(ws, {"type":"input_audio_buffer.append", "audio":base64.b64encode(material[offset:offset+640]).decode("ascii")})
                time.sleep(0.02)
            send(ws, {"type":"input_audio_buffer.commit"})
            wait_for(ws, log, "input_audio_buffer.committed")
            send(ws, {"type":"response.create"})
            pending = True
            try:
                while pending: receive(ws, log)
            except KeyboardInterrupt:
                # Cancel the actual current inference, then preserve its returned status.
                send(ws, {"type":"response.cancel"})
                while pending: receive(ws, log)
    if not complete or complete[-1].get("status") != "completed":
        raise RuntimeError("Response did not complete normally; inspect saved events and status")
finally:
    manifest = {"responses":complete, "parts":[]}
    for number, identity in enumerate(dict.fromkeys(list(audio) + list(texts))):
        record = {"response_id":identity[0], "item_id":identity[1], "output_index":identity[2], "content_index":identity[3]}
        if identity in audio:
            raw = bytes(audio[identity])
            pcm_file = out / ("audio-" + str(number) + ".pcm")
            wav_file = out / ("audio-" + str(number) + ".wav")
            pcm_file.write_bytes(raw)
            with wave.open(str(wav_file), "wb") as wav:
                wav.setnchannels(1); wav.setsampwidth(2); wav.setframerate(24000); wav.writeframes(raw)
            record.update({"pcm":str(pcm_file), "wav":str(wav_file), "sample_rate_hz":24000})
        if identity in texts:
            text_file = out / ("text-" + str(number) + ".txt")
            text_file.write_text(texts[identity], encoding="utf-8")
            record["text"] = str(text_file)
        manifest["parts"].append(record)
    (out / "results.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
    print("\nSaved every received event and result in", out)
```

### Receber e guardar os resultados

#### Ailoot · Voz em tempo real

eventos da sessão

##### Guardar todos os resultados concluídos

Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.

Reúna todos os fragmentos incrementais de áudio devolvidos e todos os resultados de texto/eventos para cada ID real de resposta.

##### Se for necessário verificar a resposta original

Conserve os IDs reais de sessão/resposta/evento e os comprovativos.

Erros e passos seguintes

| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta426 · `invalid_request_error` | CondiçãoSem mudança de protocolo para WebSocket | Passo seguinteUtilize um cliente WebSocket com Upgrade: websocket. |

### Aliases

#### Aliases do modelo

**Ailoot** [`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/pt-pt/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime)

#### Aliases dos caminhos dos métodos

Use os caminhos dos métodos indicados acima.

#### IDs de chamada relacionados

[`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/pt-pt/#m=qwen-audio-3.0-realtime-plus&route=Core&caller=qwen-audio-3.0-realtime-plus&fmt=realtime)

FAQ · qwen-audio-3.0-realtime-plus

Que entradas e resultados estão disponíveis?

`GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` · `qwen-audio-3.0-realtime-plus`: `text`, `audio` → `text`, `audio`

Que limites se aplicam?

`GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` · `qwen-audio-3.0-realtime-plus`: `session.max_history_turns.minimum`: `1`

Ligue o Ailoot ao Claude Code, OpenCode, Hermes ou à sua aplicação.

## A empresa e a sua carteira de projetos

A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.

## Compre tokens com desconto.

Desconto por subscrição para trabalho regular. Códigos promocionais — até 50% na compra de tokens.

Subscrição

Escolha um plano com desconto para os pedidos regulares.

Código promocional até 50%

Introduza o código na compra. O preço é recalculado conforme a campanha em vigor.

Custos no histórico

O modelo, os tokens e o montante são guardados para cada pedido.

[Escolher subscrição](https://ailoot.ai/docs/pt-pt/billing/subscriptions/) · [Ver preços dos modelos](https://ailoot.ai/models/pt-pt/)

## Ligue a API ao produto que vende.

SaaS, aplicações e bots — ao abrigo da oferta e do contrato de licença Ailoot. Para revenda, peça uma licença de revendedor.

Aplicação comercial

Integre geração de texto, imagens, vídeo e som nas funcionalidades pagas do seu serviço.

Licença de revendedor

Envie uma descrição do projeto e do modelo de acesso. Peça condições escritas de utilização e revenda.

Documentos no site

A oferta, o contrato de licença e a política de tratamento de dados estão disponíveis antes da ligação.

[Pedir licença de revendedor](mailto:support@ailoot.ai) · [Oferta e contrato de licença](https://ailoot.ai/legal/offer?lang=pt-pt)

## Ailoot · A empresa e a sua carteira de projetos





A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.





A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.





A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.