Soniox Real-time STT (stt-rt-v5)

Overview

Best for: Cost-sensitive multilingual live transcription and live translation, with diarization and language ID without add-on fees.

At a glance

Token-billed; $0.12/hr is the vendor calculator estimate with diarization and language ID included. 60+ languages. 300-minute stream cap cannot be raised. Concurrency raisable in console.

Features

• non-final and final tokens
• semantic endpoint detection (<end> token, tunable sensitivity and max delay)
• manual finalize (<fin> token)
• speaker separation (diarization) included
• language identification included
• context / custom vocabulary
• realtime translation
• keepalive control message
• temporary API keys for browsers

Pricing

Free tier: Not stated on the pricing page.

Source: soniox.com

Setup

1. Create an API key in the Soniox Console.
2. Connect to wss://stt-rt.soniox.com/transcribe-websocket with Authorization: Bearer <key> (or a temporary key for browsers).
3. Send a JSON start message with model, audio_format, sample_rate, num_channels and options.
4. Stream binary audio; rebuild text from tokens (append is_final tokens, redraw non-final ones).
5. Send an empty TEXT frame to finish; wait for {"finished": true}.

Endpoint

wss://stt-rt.soniox.com/transcribe-websocket

Authentication

Authorization: Bearer <API_KEY> header (api_key in the start message is deprecated); temporary API keys for client-side use.

import asyncio, json, os, websockets  # pip install websockets>=14

URL = "wss://stt-rt.soniox.com/transcribe-websocket"
CFG = {"model": "stt-rt-v5", "audio_format": "pcm_s16le", "sample_rate": 16000,
       "num_channels": 1, "enable_endpoint_detection": True}

async def main():
    hdr = {"Authorization": f"Bearer {os.environ['SONIOX_API_KEY']}"}
    async with websockets.connect(URL, additional_headers=hdr) as ws:
        await ws.send(json.dumps(CFG))
        async def send():
            with open("audio_16k_mono.raw", "rb") as f:
                while chunk := f.read(3200):  # 100 ms
                    await ws.send(chunk)
                    await asyncio.sleep(0.1)
            await ws.send("")  # empty TEXT frame ends the stream
        asyncio.create_task(send())
        final = ""
        async for msg in ws:
            d = json.loads(msg)
            if d.get("error_code"):
                print(d); break
            toks = d.get("tokens", [])
            final += "".join(t["text"] for t in toks if t["is_final"])
            partial = "".join(t["text"] for t in toks if not t["is_final"])
            print(final + " | " + partial)
            if d.get("finished"):
                break

asyncio.run(main())

Written from the current docs. Check the vendor's SDK version before you ship.

Warnings

Plus 12 warnings that apply to all speech-to-text, live APIs. See category warnings.

Limits

• 100 requests per minute, 10 concurrent streams by default (raisable in console).
• Each stream capped at 300 minutes; this cap cannot be raised.
• Open-connection limit is a multiple of the concurrent-request limit, including idle sockets.

Models and products

Docs and sources

Docs

• Pricing
• Models and changelog
• Real-time transcription
• RT limits
• WebSocket API reference

Sources used

• soniox.com/pricing
• soniox.com/docs/stt/models.mdx
• soniox.com/docs/stt/rt/limits-and-quotas.mdx
• soniox.com/docs/stt/rt/real-time-transcription.mdx
• soniox.com/docs/api-reference/stt/websocket-api.mdx