All models

Qwen-Audio-3.1-Realtime-Plus

New Launched on IteraCompute

Online

Qwen

qwen/qwen-audio-3.1-realtime-plus
Tool calling
UnsupportedTool calling · Unsupported
Reasoning
UnsupportedReasoning · Unsupported
Vision
UnsupportedVision · Unsupported
Streaming
SupportedStreaming · Supported
JSON mode
UnsupportedJSON mode · Unsupported

USD per million tokens

Text input
$0.48
Audio input
$3.84
Text output
$3.84
Audio output
$14.40
Precision
Official precision
Price checked

Overview

Send audio over a WebSocket and receive audio chunks and a transcript in the same session. Each response.done event includes usage for that turn.

Version
qwen-audio-3.1-realtime-plus
Input / output
text, audio / text, audio
Endpoint
/v1/realtime

API protocols and integration

Authorization: Bearer ITERACOMPUTE_API_KEY

  • WebSocket /v1/realtime

Connect using WebSocket. Read usage from response.done.

LLMs.txt
LLMs.txt
# qwen/qwen-audio-3.1-realtime-plus
Revision: deb6666506d9524945ea91dfdbba99d5165dbe6f350c29aadd7dfe1846563834
Authorization: Bearer ITERACOMPUTE_API_KEY
WebSocket wss://api.iteracompute.com/v1/realtime

- modalities · array · Requested response modalities.
- instructions · string · Instructions for this session.
- input_audio_format · enum · 16 kHz mono PCM16, little endian. · ["pcm"]
- output_audio_format · enum · 24 kHz mono PCM16. · ["pcm"]
- turn_detection · object · Use null for manual commit or configure voice activity detection.
- voice · string · A voice supported for this exact model.

Install websocket-client and set ITERACOMPUTE_API_KEY. Provide input.pcm as raw mono 16 kHz little-endian PCM16. The reply is saved as a playable 24 kHz WAV file.

import base64, json, os, wave
from pathlib import Path
from urllib.parse import urlencode
from contextlib import closing
from websocket import create_connection

headers = {"Authorization": "Bearer " + os.environ["ITERACOMPUTE_API_KEY"]}
url = "wss://api.iteracompute.com/v1/realtime?" + urlencode({"model": "qwen/qwen-audio-3.1-realtime-plus"})
audio = Path("input.pcm").read_bytes()
with closing(create_connection(url, header=headers, timeout=60)) as ws:
    def receive():
        event = json.loads(ws.recv())
        if event["type"] == "error":
            raise RuntimeError(event.get("error"))
        return event
    def wait_for(kind):
        while receive()["type"] != kind:
            pass
    wait_for("session.created")
    ws.send(json.dumps({"type": "session.update", "session": {"modalities": ["text", "audio"], "turn_detection": None}}))
    wait_for("session.updated")
    for offset in range(0, len(audio), 3200):
        chunk = base64.b64encode(audio[offset:offset+3200]).decode("ascii")
        ws.send(json.dumps({"type": "input_audio_buffer.append", "audio": chunk}))
    ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
    wait_for("input_audio_buffer.committed")
    ws.send(json.dumps({"type": "response.create"}))
    with wave.open("reply.wav", "wb") as out:
        out.setparams((1, 2, 24000, 0, "NONE", "PCM"))
        while True:
            event = receive()
            if event["type"] == "response.audio.delta":
                out.writeframesraw(base64.b64decode(event["delta"]))
            elif event["type"] == "response.done":
                if event["response"]["status"] != "completed":
                    raise RuntimeError(event["response"]["status"])
                break

https://www.alibabacloud.com/help/en/model-studio/audio-realtime-websocket-access

API parameters

  • Connect using WebSocket. Read usage from response.done.

These parameters and ranges describe the current route. Account and context limits also apply. Parameter acceptance does not establish model capability.

Tool calling
Unsupported
Reasoning
Unsupported
Vision
Unsupported
Streaming
Supported
JSON mode
Unsupported

Parameters and values

Click a parameter to copy its name; scroll the table horizontally to see all columns. Usage notes identify protocol differences; identical names do not guarantee cross-endpoint support.

ParameterTypeAcceptanceRangeUsage / protocol
stringAccepted—A voice supported for this exact model.
arrayAccepted—Requested response modalities.
stringAccepted—Instructions for this session.
objectAccepted—Use null for manual commit or configure voice activity detection.
enumAccepted["pcm"]16 kHz mono PCM16, little endian.
enumAccepted["pcm"]24 kHz mono PCM16.

Current configuration example

WebSocket /v1/realtime

Example request
{
  "type": "session.update",
  "session": {
    "modalities": [
      "text",
      "audio"
    ],
    "turn_detection": null
  }
}

Parameter revision:deb6666506d9

API

Install websocket-client and set ITERACOMPUTE_API_KEY. Provide input.pcm as raw mono 16 kHz little-endian PCM16. The reply is saved as a playable 24 kHz WAV file.

Python
import base64, json, os, wave
from pathlib import Path
from urllib.parse import urlencode
from contextlib import closing
from websocket import create_connection

headers = {"Authorization": "Bearer " + os.environ["ITERACOMPUTE_API_KEY"]}
url = "wss://api.iteracompute.com/v1/realtime?" + urlencode({"model": "qwen/qwen-audio-3.1-realtime-plus"})
audio = Path("input.pcm").read_bytes()
with closing(create_connection(url, header=headers, timeout=60)) as ws:
    def receive():
        event = json.loads(ws.recv())
        if event["type"] == "error":
            raise RuntimeError(event.get("error"))
        return event
    def wait_for(kind):
        while receive()["type"] != kind:
            pass
    wait_for("session.created")
    ws.send(json.dumps({"type": "session.update", "session": {"modalities": ["text", "audio"], "turn_detection": None}}))
    wait_for("session.updated")
    for offset in range(0, len(audio), 3200):
        chunk = base64.b64encode(audio[offset:offset+3200]).decode("ascii")
        ws.send(json.dumps({"type": "input_audio_buffer.append", "audio": chunk}))
    ws.send(json.dumps({"type": "input_audio_buffer.commit"}))
    wait_for("input_audio_buffer.committed")
    ws.send(json.dumps({"type": "response.create"}))
    with wave.open("reply.wav", "wb") as out:
        out.setparams((1, 2, 24000, 0, "NONE", "PCM"))
        while True:
            event = receive()
            if event["type"] == "response.audio.delta":
                out.writeframesraw(base64.b64decode(event["delta"]))
            elif event["type"] == "response.done":
                if event["response"]["status"] != "completed":
                    raise RuntimeError(event["response"]["status"])
                break

Manage API keys

Pricing

USD per million tokens

Text input$0.48
Audio input$3.84
Text output$3.84
Audio output$14.40
Model ID
qwen/qwen-audio-3.1-realtime-plus
Verification scope and sources
View verification scope and sources

2026-11-21 · Singapore WebSocket tests verified PCM audio, text-only output and independent billing for sequential turns, and estimated settlement after a confirmed cancellation when supplier usage was missing.

Usage limits

  • Audio replies include the transcript without a separate text output charge.

Use cases

Stream audio and text over a real-time connection.

Integration tools and guides

FAQ

How do I get started?

Open the native API example for this model

How is usage billed?

USD per million tokens

New arrivals

Explore the models selected for New Arrivals, with API pricing, supported capabilities and integration guides.

View new arrivals
QwenNew

Qwen3.7-Plus

qwen/qwen3.7-plus

Qwen3.7-Plus returns text from text and visual input.

Launched on IteraCompute

Input
$0.384
Output
$1.536

USD / 1M tokens