Per-second speech-to-text billing: why an open, silent stream still costs money

Why streaming speech recognition is billed by time

A streaming transcriber is billed like a taxi meter, not like a word count: the meter runs from the moment the stream opens until it closes. That is fair, because the service holds a connection and a slot on its servers for the whole time, listening for speech it cannot predict. It also means the cost of a call depends on how long the stream stays open, which is often longer than the call and always longer than the talking.

Per-second billing means the meter counts in one-second steps, so a 61-second stream is billed as 61 seconds rather than rounded up to two minutes. The price is usually quoted per minute or per hour. Sonex Labs' Valmiki speech-to-text model is a plain example: $0.00525 per minute of audio, billed by the second, which is $0.0000875 a second. A stream is billed for as long as it is open, on a phone call, in the dashboard playground and through the API alike.

The table shows one 5-minute call four ways at that rate, assuming the caller speaks for 90 seconds in total. Only the last row bills for speech alone, and no streaming service known to us works that way; it is there to show how much of the bill is silence. Rupee figures use ₹95.04 to the dollar (open.er-api.com, 24 October 2026).

Two ways vendors meter a streaming session

Vendors agree on charging for time but differ on which time, and the difference decides which savings work. Some count the session: every second the connection is open. Others count the audio: every second of sound you actually send. A third question is rounding, since a vendor that rounds each session up to a minimum charges short sessions more than their length.

Rounding matters most for short calls. Deepgram, which places itself among per-second vendors, writes that some competitors round each stream up to 15-second blocks or a full minute, and gives the example of an 11-second IVR call billed as 15 seconds (Deepgram's pricing breakdown). That is one competitor describing others, so read each vendor's own billing terms rather than a summary.

• Where the session is the meter, pausing the audio saves nothing; only closing the stream helps.
• Where the audio is the meter, stop sending during long silences and send keep-alives, which keeps reconnects off the critical path.
• Either way, find out whether each session is rounded up to a minimum before optimising.

Where the silent seconds come from on a phone call

Most silence on a call cannot be avoided, and some of it you pay for on purpose. Pauses between turns are short and need the stream open. While the agent speaks, the stream must keep listening if you want the caller to be able to interrupt, which is what makes barge-in work; how voice bots handle interruptions and backchannels explains why that matters. Holds, transfers, voicemail greetings and IVR menus are longer and usually need no transcription at all.

The expensive silence is the kind nobody sees: streams left open after the call has ended. In Sonex's call engine, the pipeline normally shuts every service down on hang-up. When one processor stalled that shutdown, the speech-to-text connection was never told to close, and its socket ran on in the background for tens of seconds. Under back-to-back calls, enough of these zombie sessions piled up to exceed an upstream limit on concurrent sessions, and the next calls' transcription failed with HTTP 429 (too many requests) errors. The engine now closes the STT connection directly on hang-up, with a 2-second limit, instead of relying on the shutdown to reach it.

Clients cause the same leak from the other end. On Sonex's public streaming API, a test client once sent a 4.5-second clip and then held the connection until the idle timer closed it, and was billed for 36 seconds. The API now ends a session as soon as the client sends {"type": "end"}, after giving the last words up to 5 seconds to finalise. It also closes any session with no recognised speech for 30 seconds, and caps a single connection at 10 minutes. The sample below ends its session explicitly; a fuller speech-to-text API tutorial in Python covers files and options.

import asyncio
import json
import wave

import websockets  # version 13 or later


async def transcribe(path: str) -> None:
    async with websockets.connect(
        "wss://api.sonexlabs.com/v1/transcribe/stream",
        additional_headers={"Authorization": "Bearer YOUR_API_KEY"},
    ) as ws:
        while json.loads(await ws.recv())["type"] != "ready":
            pass
        with wave.open(path, "rb") as w:  # 16 kHz mono 16-bit PCM
            frames = w.getframerate() // 10  # 100 ms per message
            while chunk := w.readframes(frames):
                await ws.send(chunk)
                await asyncio.sleep(0.1)  # real time, like a live caller
        await ws.send(json.dumps({"type": "end"}))  # stop the meter now
        async for message in ws:
            event = json.loads(message)
            if event["type"] == "final":
                print(event["text"])
            elif event["type"] == "done":
                print("seconds billed:", event["seconds_billed"])


asyncio.run(transcribe("call_16k.wav"))

How to close streams on hang-up, hold and silence

Close on clear events, not on guesses. Hang-up is the clearest: close the STT connection yourself, directly and with a timeout, the moment the carrier reports the call has ended, and log the open and close times with the call ID. Then compare your provider's count of sessions with your count of calls. More sessions than calls, or provider minutes well above call minutes, means something is leaking.

Holds and transfers are the next easiest, because your own system starts them. Close the stream when hold music starts or the call leaves for a human, and open a new one when the caller returns to the agent. Open it a moment before you need it, buffer the caller's audio while the connection is set up, and send the buffer first. A new stream needs a network handshake and a session setup, and audio that arrives in that gap is otherwise lost.

Long silence in the middle of a conversation is the hardest case. A local voice activity detector (VAD), software that decides whether a stretch of audio contains speech, can tell you no one has spoken for, say, 15 seconds, the idle limit Sonex uses in its dashboard playground. With an audio-metered vendor, stop sending and switch to keep-alives. With a session-metered vendor, closing is the only saving, so keep the limit long enough that a caller who is thinking is not cut off, and reopen on the first sign of speech. A VAD can also clip the start of speech, so test it on real calls; silence handling on Twilio media streams shows what phone-line silence looks like in practice.

When keeping the stream open is the right call

Closing streams has costs of its own, and at small volumes they can outweigh the savings. Each reconnect risks clipping the first syllable of the caller's next sentence, and some services carry context across a session that a new stream loses. Every extra open and close is also one more thing that can fail in the middle of a call, and a missed word costs more in a booking or a payment call than a few seconds of transcription.

So do the arithmetic for your own volume before writing the code. Closing during a 2-minute hold saves 120 seconds, $0.0105 per call at Valmiki's rate. Across 100,000 such calls a month that is $1,050, worth an afternoon of engineering; across 1,000 it is $10.50, and probably not. The zombie-session fix is different: it costs almost nothing to build, saves 30 seconds per affected call in the table above, and prevents an outage, so do it whatever your volume.

Keep the line in proportion, too. In a quality API stack priced in October 2026, speech-to-text was about a fifth of the cost per call-minute, behind text to speech, as the self-hosting cost model breaks down. The same time-based meter also applies to a self-hosted GPU, which bills every hour it runs, a point the self-hosted Whisper comparison takes further. Fix the leaks first, then the holds, and leave the pauses inside a live conversation alone.