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

# qwen-audio-3.0-realtime-plus

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

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

Een model voor live spraakgesprekken dat spraak en tekst accepteert en met stem of tekst antwoordt. Het is ontworpen voor een natuurlijk gesprekstempo en samenwerking met tools.

- [**Ailoot · Realtime spraak** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus` `qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/nl/qwen-audio-3-0-realtime-plus/#method-0)

Over het model

Deze beschrijving gaat over de mogelijkheden van het model. De via Ailoot beschikbare invoer, uitvoer en opties staan hieronder voor de geselecteerde methode.

Qwen-Audio-3.0-Realtime-Plus is een model van Alibaba voor live spraakgesprekken. Het accepteert spraak en tekst, antwoordt met audio en tekst en ondersteunt een gesprek in twee richtingen met een natuurlijke uitwisseling van uitspraken. Audio kan in delen worden verzonden en ontvangen, zodat de interactie zich tijdens het gesprek ontwikkelt.

#### Wanneer de gesprekspartner is uitgepraat

Er zijn meerdere manieren om het einde van een uitspraak te bepalen: via geluidsactiviteit, inhoudelijke afronding en expliciete besturing. Bij de fabrikant wordt de modus gekozen voordat de eerste audio wordt verzonden; wijzigen nadat het gesprek is begonnen vereist een nieuwe verbinding. Ondersteuning voor deze besturing hangt af van de gekozen methode. De semantische modus houdt rekening met pauzes en opvulwoorden: een korte aarzeling betekent niet noodzakelijk dat de gebruiker is uitgepraat. Nieuwe spraak van de gebruiker kan het antwoord dat wordt gegenereerd onderbreken, zodat het gesprek doorgaat met de volgende uitspraak in gedachten. In de semantische modus kan de herkenning worden gericht op een stemvoorbeeld van de gekozen gesprekspartner om minder te worden afgeleid door andere stemmen en achtergrondgeluid.

Instructies bepalen de rol van de assistent en de gespreksstijl. De stem kan rekening houden met toon, tempo en emotie; versie 3.0 biedt vijf systeemstemmen en stemmen op basis van een spraakvoorbeeld. Het model ondersteunt 11 talen, waaronder Russisch, en de Chinese dialectvarianten die de fabrikant noemt. Bij de fabrikant wordt de stem ingesteld bij de eerste update van de sessie-instellingen; een nieuwe stem die later in hetzelfde gesprek wordt doorgegeven, wordt genegeerd. Deze instellingen vereisen ondersteuning door de gekozen aanroepmethode.

#### Tools en gespreksgeschiedenis

Functieaanroepen worden ondersteund. Het model formuleert de gewenste actie, de gekoppelde toepassing voert die uit en geeft het resultaat terug in het gesprek. Zo kan een gesprek worden opgebouwd rond feitelijke gegevens en doorgaan nadat een handeling is uitgevoerd. De spraakassistent kan voortbouwen op toolresultaten met behoud van de gesprekscontext. De mogelijkheden van de fabrikant omvatten ook ingebouwd zoeken op het web, als de gekozen methode dit biedt. Zoeken op het web en functieaanroepen kunnen niet tegelijk in één sessie worden ingeschakeld.

De geschiedenis bevat standaard 20 gespreksbeurten, met een instelbaar bereik van één tot 50. Voor verzamelde audio geldt een grens van 300 seconden; oude delen van de geschiedenis worden verwijderd wanneer de grenzen worden overschreden. Dit verschilt van de duur van een afzonderlijke uitspraak: de geschiedenis bepaalt welk eerder materiaal beschikbaar blijft bij het voortzetten van het gesprek.

#### Tekstcontext en audio

De formele context is 40 960 tokens. De maximale invoerlengte is 16 384 tokens en de maximale uitvoerlengte 8192; dezelfde in- en uitvoergrenzen gelden voor de redeneermodus, met een afzonderlijke grens van 1024 tokens voor de redeneerketen.

Streaming audio gebruikt éénkanaals PCM met 16-bits representatie: 16 kHz voor invoer en 24 kHz voor uitvoer. Tekst- en audiogegevens horen bij hetzelfde gesprek. Voor dit specifieke model zijn visuele invoer en uitvoer van afbeeldingen niet aangekondigd; het is gespecialiseerd in spraak, tekst en gesproken interactie.

**Ailoot · Realtime spraak** `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/nl/#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`

### Aan de slag

Een model voor live spraakgesprekken dat spraak en tekst accepteert en met stem of tekst antwoordt. Het is ontworpen voor een natuurlijk gesprekstempo en samenwerking met tools.

Toegestane invoer

Tekst · Audio

Resultaten

Tekst · Audio

### Beschikbaar in Ailoot · invoer en methoden

**Ailoot · Realtime spraak** `GET /v1/realtime?model=qwen-audio-3.0-realtime-plus`

Invoertypen

`text`, `audio`

Uitvoertypen

`text`, `audio`

Uitvoerformaat

sessiegebeurtenissen

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`query.model` | Type`string` | VereisteVereist | Waarden en limieten qwen-audio-3.0-realtime-plus | Standaard— |
| Veld`session.input_audio_format` | Type`string` | VereisteOptioneel | Waarden en limieten pcm16, pcm | Standaard— |
| Veld`session.output_audio_format` | Type`string` | VereisteOptioneel | Waarden en limieten pcm16, pcm | Standaard— |
| Veld`session.instructions` | Type`string` | VereisteOptioneel | Waarden en limieten Limiet geldt voor: geselecteerd sessiebeleid | Standaard— |
| Veld`session.max_history_turns` | Type`integer` | VereisteOptioneel | Waarden en limieten Minimum: 1 Limiet geldt voor: geselecteerd sessiebeleid | Standaard— |
| Veld`input_audio_buffer.append.audio` | Type`base64_string` | VereisteVereist | Waarden en limieten Invoerinhoud: PCM16 mono; 16 kHz invoer, 24 kHz uitvoer; een positief, even aantal bytes | Standaard— |

Combinaties van invoermaterialen

**realtime\_text\_audio**

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`material_types` | Contracttext, audio |
| Parameter`required` | Contractnull |
| Parameter`optional_controls` | Contractnull |
| Parameter`content_type` | ContractWebSocket |

Levenscyclus: `exact retained published method`

De methodestructuren en ID’s zijn exact; de mogelijkheden van de leverancier staan los van toelating.

### Tarieven

#### Ailoot-methodetarieven

Invoer

US$ 0,0008 */ 1K*

Uitvoer

US$ 0,0064 */ 1K*

Invoer

US$ 0,0048 *per minuut audio*

Uitvoer

US$ 0,018 *per minuut audio-uitvoer*

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

### Voorbeeldverzoeken

#### Ailoot · Realtime spraak

Python WebSocket · tekstPython WebSocket · audio

```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)
```

### Resultaten ophalen en opslaan

#### Ailoot · Realtime spraak

sessiegebeurtenissen

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Voeg elke geretourneerde audiodelta en elk tekst-/gebeurtenisresultaat samen voor elke daadwerkelijke antwoord-ID.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar de daadwerkelijke sessie-/antwoord-/gebeurtenis-IDs en ontvangstbewijzen.

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord426 · `invalid_request_error` | VoorwaardeGeen WebSocket-upgrade | Volgende stapGebruik een WebSocket-client met Upgrade: websocket. |

### Aliasnamen

#### Modelaliasnamen

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

#### Aliasnamen voor methodepaden

Gebruik de hierboven getoonde methodepaden.

#### Gerelateerde aanroeper-ID’s

[`qwen-audio-3.0-realtime-plus`](https://ailoot.ai/models/nl/#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

Welke invoer en resultaten zijn beschikbaar?

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

Welke limieten gelden?

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

Verbind Ailoot met Claude Code, OpenCode, Hermes of je eigen applicatie.

## Het bedrijf en zijn projectenportefeuille

Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.

## Koop tokens met korting.

Abonnementsvoordeel voor regelmatig gebruik. Promotiecodes geven tot 50% korting op tokens.

Abonnement

Kies een abonnement met korting voor je terugkerende verzoeken.

Promotiecode tot 50%

Vul de code bij aankoop in. De prijs wordt volgens de lopende actie herberekend.

Kosten in de geschiedenis

Model, tokens en bedrag worden per verzoek bewaard.

[Kies een abonnement](https://ailoot.ai/docs/nl/billing/subscriptions/) · [Bekijk modelprijzen](https://ailoot.ai/models/nl/)

## Verbind de API met het product dat je verkoopt.

SaaS, apps en bots volgens de openbare aanbodvoorwaarden en licentieovereenkomst van Ailoot. Vraag voor doorverkoop een resellerlicentie aan.

Commerciële applicatie

Voeg tekst-, beeld-, video- en geluidsgeneratie aan betaalde functies van je service toe.

Resellerlicentie

Stuur een projectbeschrijving en toegangsschema. Vraag schriftelijke voorwaarden voor gebruik en doorverkoop.

Documenten op de site

Aanbodvoorwaarden, licentieovereenkomst en gegevensbeleid zijn vóór het verbinden beschikbaar.

[Vraag een resellerlicentie aan](mailto:support@ailoot.ai) · [Aanbodvoorwaarden en licentieovereenkomst](https://ailoot.ai/legal/offer?lang=nl)

## Ailoot · Het bedrijf en zijn projectenportefeuille





Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle.





Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.





Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.