Use case · Voice agents

Speech-to-text for voice agents

A voice agent can't answer until it knows what the user said. The wait between the user's last word and the final transcript is dead air on every turn. Wire-1, Saidwire's real-time English speech-to-text model, returns that final transcript 50 ms after the end of speech at the 95th percentile. Ranked 1st of 29 on mean time to final segment (35 ms) in Coval's independent STT benchmark, 30-day window to Nov 9, 2026, 2,857 samples. Source: Coval model page, 30-day window to Nov 9, 2026, 2,857 samples, US-hosted endpoint. Add your own network round trip. Method and how to reproduce.

How a fast turn works

Stream the user's audio over a WebSocket to wss://api.saidwire.com/v1/listen. Interim results arrive while they speak, so your agent can prepare.
Your VAD or turn detector decides the user has finished. Send {"type": "Finalize"}.
The final transcript comes straight back, with punctuation and word timings, marked from_finalize: true. Hand it to your LLM.

Without Finalize, set endpointing to the pause that ends a turn (minimum 500 ms) and use speech_final. Finalize is faster because your app decides when the turn ends.

With a framework

The Pipecat and LiveKit Agents plugins send Finalize for you when the VAD says the user stopped. On Vapi, use the custom transcriber.

# Pipecat:  pip install pipecat-saidwire
from pipecat_saidwire import SaidwireSTTService
stt = SaidwireSTTService()   # reads SAIDWIRE_API_KEY

# LiveKit Agents:  pip install livekit-plugins-saidwire
from livekit.plugins import saidwire
session = AgentSession(stt=saidwire.STT(), vad=silero.VAD.load(), llm=..., tts=...)

With your own code

# pip install websockets   (Python 3.10+)
import asyncio, json, os
from websockets.asyncio.client import connect

URL = ("wss://api.saidwire.com/v1/listen?encoding=linear16&sample_rate=16000"
       "&interim_results=true&punctuate=true&endpointing=false")

async def run(frames):                     # frames: 20-100 ms chunks of 16-bit PCM
    headers = {"Authorization": f"Token {os.environ['SAIDWIRE_API_KEY']}"}
    async with connect(URL, additional_headers=headers) as ws:
        async def read():
            async for raw in ws:
                m = json.loads(raw)
                if m.get("type") == "Results":
                    text = m["channel"]["alternatives"][0]["transcript"]
                    print("final  " if m["is_final"] else "interim", text)
        reader = asyncio.create_task(read())
        async for chunk in frames:
            await ws.send(chunk)
        # your turn detector says the user stopped: ask for the final now
        await ws.send(json.dumps({"type": "Finalize"}))
        await ws.send(json.dumps({"type": "CloseStream"}))
        await reader

Options that help agents

parameter	what it does
`keyterm=`	names, products and terms your users will say, spelled the way you wrote them in finals (repeat once per term, up to 100)
`noise_guard=true`	drops words that come from faint background sound (a TV, a fan) so they can't interrupt your bot
`early_words=true`	an `EarlyWord` message for each word as soon as it is committed, useful for "stop" or "cancel"
`timing=true`	`server_ms` on each final: our time on the server, so you can see your own network time
`vad_events=true`	a `SpeechStarted` message when the user starts talking, for barge-in

Measured on agent audio

Audio condition (Coval)	Mean time to final segment
Accented speech	26 ms
Noise and gaps	34 ms
Production voice-agent audio (Pipecat)	34 ms
Phone codec	38 ms

Source: Coval model page, 30-day window to Nov 9, 2026, 2,857 samples, US-hosted endpoint. Add your own network round trip. Method and how to reproduce.

Questions

How fast is the final transcript?

50 ms p95 and 35 ms mean from the end of speech to the final transcript on Coval's STT benchmark (30-day window to Nov 9, 2026), when the client sends Finalize. Add your network round trip.

Do I need my own turn detector?

For the quickest turns, yes: send Finalize when it fires. Otherwise server endpointing ends turns after a pause you choose (500 ms or more).

Which frameworks work?

Pipecat and LiveKit Agents have plugins, Vapi has a hosted custom transcriber, and any /v1/listen-compatible client can point at wss://api.saidwire.com.

What does it cost?

120 free hours with no card and no deadline, up to 4 streams at once, then $0.25 per audio hour, billed per second.

Questions or stuck? Email support@saidwire.com with the request ID from the failed call.

Pipecat, LiveKit, Vapi, OpenAI and the other names on this page belong to their respective owners. They are named only to describe compatibility; no partnership or endorsement is implied. Coval benchmark figures are from Coval's public model page; Coval does not endorse Saidwire.