All models

Qwen3.8-Omni-Flash-Realtime

New Launched on IteraCompute

Online

Qwen

qwen/qwen3.8-omni-flash-realtime
Tool calling
UnsupportedTool calling · Unsupported
Reasoning
UnsupportedReasoning · Unsupported
Vision
SupportedVision · Supported
Streaming
SupportedStreaming · Supported
JSON mode
UnsupportedJSON mode · Unsupported

USD per million tokens

Text / image / video input
$0.23
Audio input
$0.93
Text output
$0.70
Audio output
$1.87
Precision
Official precision
Price checked

Overview

Send audio over a WebSocket and optionally append image frames before committing the audio turn. Receive audio chunks and a transcript, then read usage by modality in response.done.

Version
qwen3.8-omni-flash-realtime
Input / output
text, audio, image, video / 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/qwen3.8-omni-flash-realtime
Revision: 60543f71d943c248156389ae7199301bfebbd3586618b90a2c030cdec810f601
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. For visual input, send an audio chunk first, then input_image_buffer.append with a Base64 JPEG in the image field.

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/qwen3.8-omni-flash-realtime"})
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/realtime

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
Supported
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:60543f71d943

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. For visual input, send an audio chunk first, then input_image_buffer.append with a Base64 JPEG in the image field.

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/qwen3.8-omni-flash-realtime"})
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 / image / video input$0.23
Audio input$0.93
Text output$0.70
Audio output$1.87
Model ID
qwen/qwen3.8-omni-flash-realtime
Verification scope and sources
View verification scope and sources

2026-11-21 · Singapore WebSocket tests verified audio, red and blue image recognition, independent billing for sequential turns, and estimated settlement after a confirmed cancellation when supplier usage was missing.

Usage limits

  • Audio and its accompanying text are billed separately.

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