Real-time Arabic transcription over WebSocket (a drop-in for Deepgram clients)

Meeting recorders, note takers, call loggers and live captioning all need the same thing: audio goes in continuously, text comes out as people talk. For Arabic that has been hard to find. This guide covers real-time Arabic transcription over nutq's WebSocket — the connection, the messages, and the honest limits worth knowing before you build on it.

Why is real-time Arabic transcription hard to find?

Most streaming speech APIs were built English-first. Deepgram, the default on many platforms, has no dedicated Arabic model — nova-2 and nova-3 reject ar — so teams who already built on it have had no Arabic path. nutq's socket speaks Deepgram's live protocol on purpose: if you have that client, you change a URL, not an architecture.

How do you connect?

wss://worker.nutq.dev/v1/listen?encoding=linear16&sample_rate=16000&channels=1&language=auto

Authenticate with Authorization: Token <key> (what a Deepgram client sends), a Bearer header, or ?key= on the URL for platforms that cannot set handshake headers. The URL form ends up in access logs, so give it its own key.

What do you send?

• Binary frames of raw PCM at the rate and channel count you declared. Any frame size.
• {"type":"KeepAlive"} — accepted; the socket is not closed for being quiet.
• {"type":"Finalize"} — return whatever is buffered now, when you stop mid-sentence.
• {"type":"CloseStream"} — finish and close; a Metadata frame reports the billed duration.

What comes back?

{
  "type": "Results",
  "start": 14.30,
  "duration": 14.70,
  "is_final": true,
  "speech_final": true,
  "channel": {
    "alternatives": [{
      "transcript": "تعلمت إن مو لازم كل شي يصير بسرعة",
      "confidence": null,
      "words": [],
      "language": "ar"
    }]
  }
}

Note the transcript: Gulf dialect, as spoken, not rewritten into Modern Standard Arabic. Why that matters is covered in Gulf Arabic vs MSA.

What are the limits?

Better to know these before you design an interface around them:

• No interim results. Every result is final, about 700 ms after someone stops talking. Words do not appear one by one while they speak.
• confidence is null. The model produces no calibrated score, so none is invented.
• words is empty. There are no word-level timings, but start and duration on each result are real, so you can still jump to a moment.
• Long unbroken speech is cut at about 15 seconds, at the quietest point near that mark, so a non-stop talker produces a result roughly every fifteen seconds.

For live captions that must track each word as it is spoken, this is the wrong tool. For notes, logs, call records and captions that appear a sentence at a time, it fits.

Which sample rate and channels should you send?

Send audio at its real rate. Telephone audio is 8000 Hz, so send it as that with sample_rate=8000; upsampling adds nothing the model can use. Declare the channel count you actually send — announcing one channel and sending two transcribes every other sample. For call recordings with the customer on one channel and the agent on the other, pick the side you want with channel, or open two sockets to get a transcript per speaker.

linear16 is the only encoding accepted. Anything else is refused at connect time rather than played back as noise, so a misconfigured client fails at once instead of after an hour of empty transcripts.

A minimal Python client

import asyncio, json, websockets

URL = ("wss://worker.nutq.dev/v1/listen"
       "?encoding=linear16&sample_rate=16000&channels=1&language=auto")

async def main(pcm_frames):
    async with websockets.connect(
        URL, additional_headers={"Authorization": f"Token {NUTQ_API_KEY}"}
    ) as ws:
        async def send():
            for frame in pcm_frames:
                await ws.send(frame)
            await ws.send(json.dumps({"type": "CloseStream"}))

        async def read():
            async for raw in ws:
                m = json.loads(raw)
                if m["type"] == "Results":
                    print(m["channel"]["alternatives"][0]["transcript"])
                elif m["type"] == "Metadata":
                    return

        await asyncio.gather(send(), read())

Live or batch?

For recordings, one POST is simpler — see the Arabic speech to text API guide. For phone agents, the same streaming engine is wired into Vapi in building an Arabic voice agent. Every message is in the API reference, and your first $5 is free at sign-up.