Deepgram Nova-3 and Flux (streaming)

Overview

Best for: Cheap, high-concurrency English or multilingual live captions (Nova-3) and voice agents that want turn detection from the STT itself (Flux).

At a glance

Price is Nova-3 monolingual PAYG ($0.0048/min, marked promotional); Flux English is $0.39/hr. Latency is Flux end-of-turn (~260 ms); no Nova-3 figure. 59 languages for Nova-3; code-switching across 10. Diarization, keyterms and redaction are paid add-ons. HIPAA, SOC 2 and EU endpoint are vendor claims, not re-verified. 10 s idle timeout, no session cap stated.

Features

• interim results (Nova-3)
• endpointing and utterance end (Nova-3)
• model-integrated end-of-turn with EagerEndOfTurn / TurnResumed (Flux)
• diarization (paid add-on in streaming, Nova-3)
• keyterm prompting (paid add-on)
• redaction (paid add-on)
• smart formatting (included)
• word timestamps
• Configure message to change Flux settings mid-stream
• ForceEndTurn for bring-your-own turn detection

Pricing

Free tier: $200 free credit for new accounts, does not expire until used (pricing page).

Source: deepgram.com

Setup

1. Create an API key in the Deepgram console.
2. Open wss://api.deepgram.com/v1/listen with model=nova-3 (or wss://api.deepgram.com/v2/listen?model=flux-general-en for Flux).
3. Send header Authorization: Token <key>; for browsers mint a short-lived JWT server-side (token-based auth, 30 s TTL).
4. Stream raw audio frames, send KeepAlive during silence, send {"type":"CloseStream"} to flush and close.

Endpoint

wss://api.deepgram.com/v1/listen (Nova-3) ; wss://api.deepgram.com/v2/listen (Flux)

Authentication

Authorization: Token <API_KEY> header. Browser: temporary JWT from the token-based auth endpoint (30 second TTL to open the socket).

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

URL = ("wss://api.deepgram.com/v1/listen?model=nova-3&encoding=linear16"
       "&sample_rate=16000&interim_results=true&endpointing=300")

async def main():
    hdr = {"Authorization": f"Token {os.environ['DEEPGRAM_API_KEY']}"}
    async with websockets.connect(URL, additional_headers=hdr) as ws:
        async def send():
            with open("audio_16k_mono.raw", "rb") as f:  # 16-bit PCM mono
                while chunk := f.read(3200):  # 100 ms
                    await ws.send(chunk)
                    await asyncio.sleep(0.1)  # pace at real time
            await ws.send(json.dumps({"type": "CloseStream"}))
        asyncio.create_task(send())
        async for msg in ws:
            d = json.loads(msg)
            if d.get("type") == "Results":
                text = d["channel"]["alternatives"][0]["transcript"]
                if text:
                    print("FINAL" if d["is_final"] else "partial", text)

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

• Concurrency: 150 WebSocket STT streams on Pay As You Go, 225 on Growth (pricing page).
• Connection closes with NET-0001 if no audio or KeepAlive for 10 seconds; send KeepAlive (text frame) every 3-5 s.
• Whisper Cloud limited to 5 concurrent requests.

Models and products

Docs and sources

Docs

• Pricing
• Flux quickstart
• Models and languages
• Audio keep alive
• Token-based auth

Sources used

• deepgram.com/pricing
• developers.deepgram.com/docs/flux/quickstart
• developers.deepgram.com/docs/flux/feature-overview.md
• developers.deepgram.com/docs/audio-keep-alive.md
• developers.deepgram.com/docs/models-languages-overview.md