Best Speech-to-Text and AI Voice APIs in 2026: Hosted and Open Source Compared

This number came off a laptop on a desk, not a vendor benchmark. A nine second WAV file, transcribed locally on the CPU with faster-whisper and the base.en model, took 0.6 seconds. It got exactly one word wrong: it heard "Dev Tulab" instead of "DevToolLab". One line of vocabulary hinting fixed that, and the next run was perfect. Cost: nothing. Setup: about two minutes, and most of that was the model downloading.

That is where speech recognition sits in 2026. For clean audio in a major language, accuracy is basically a solved problem, on hosted APIs and open weights alike. The decisions left are the ones that actually affect your build: time to first partial, whether the model can tell a pause from the end of a turn, how badly your product names break it, and what the meter is counting when you get billed for a WebSocket connection instead of audio minutes.

This guide splits "voice API" into the three separate jobs it actually covers, compares every hosted provider at its published rate, gives self-hosted open models equal weight, and ends with a checklist you can work through in an afternoon.

Three Jobs Hiding Behind One Label

The first job is batch transcription. You have a file already on disk, a podcast episode, a support call, a lecture, and you want the most accurate text out of it. Latency is irrelevant here. What matters is cost per audio hour and accuracy on names, numbers and jargon, which decides whether the transcript is searchable or whether someone has to clean it up by hand.

The second is real-time streaming for voice agents, where the transcript is only half the problem. The harder half is turn detection: deciding the caller has finished rather than paused mid-thought. Get it wrong and your agent either talks over people or sits silent for two seconds. Most pipelines still solve this with a silence timer bolted on after the ASR, and that is exactly where the newest models have split away from classic transcription.

The third is speech synthesis, turning text back into audio. Different vendors, different latency numbers, and a stronger open-source scene than most people expect. A voice agent needs all three plus an LLM in the middle, and it is the sum of those four latencies, not any one of them, that decides whether the conversation feels natural.

Keeping these separate matters because the best provider for one is frequently not the best for another. The most accurate batch model in 2026 is not the one you want driving a phone agent, and the fastest streaming model is not the one you want transcribing a two hour deposition.

Quick Comparison

Every price above is the vendor's published pay-as-you-go list rate as of August 2026, before any prepaid or committed-use discount. Read the billing section further down before you build a cost model from this table, because two providers on it measure "an hour" differently.

The free tiers differ in kind, not just in size. Deepgram, Speechmatics and AssemblyAI give you one-off credit, $200, $100 and $50, which you burn down once and then start paying. At list rates that buys roughly 690 hours of Nova-3 batch, 775 hours of Melia batch or 238 hours of Universal-3.5 Pro async, far more than any evaluation needs. Neither Speechmatics nor AssemblyAI asks for a card, so trying them costs nothing but your time.

Google and ElevenLabs work the other way, with a recurring monthly allowance instead of a one-time grant. Google gives 60 minutes every month with no expiry, plus the usual $300 of GCP credit for the first 90 days, which makes it the only option here that stays free forever at low volume. ElevenLabs includes 4.5 hours of Scribe v2 batch and 2.5 hours of realtime per month on the free plan, and because the per-hour rate is identical on every tier, what you measure on the free plan is what you get in production. OpenAI is the outlier with no free audio allowance at all: billed from the first minute. The open models have no tier, just whatever your GPU can chew through.

Speechmatics Melia-1

Speechmatics has been shipping speech recognition since long before it was an AI category, and Melia is what put it back on top. In a July 2026 benchmark across 14 commercial models and 16 datasets, Melia-1 posted the best aggregate word error rate at 6.4%, ahead of AssemblyAI Universal-3.5 Pro at 7.0%, OpenAI Whisper-1 at 8.3% and Deepgram Nova-3 English at 8.9%, at a fraction of the price of the models directly behind it.

Code-switching is the real differentiator. Melia handles all 56 or more languages in one pass: no per-language model to select, no language hint to send up front. When a speaker starts a sentence in Spanish and finishes it in English, which happens constantly in real support audio, you get both halves right instead of a mangled boundary. Most competitors either need the language declared in advance or fall apart at the switch.

Pricing is where most comparisons get this wrong. Melia batch starts at $0.129 per hour against $0.24 for the older Standard model, so the most accurate model in this comparison is also the cheapest hosted option in it. Volume discounts apply automatically above 500 hours, another tier kicks in past 24,000 hours a year, and committing to a plan takes 20% more off. New accounts get $100 of credit and two concurrent real-time sessions, no card.

A newest model that undercuts the legacy one is backwards from how most vendors price, and worth exploiting. The trade-off: Speechmatics does far less developer marketing than the others here, so the SDKs are thinner and there is less community answer volume. Expect to read the official docs rather than find a Stack Overflow thread.

AssemblyAI Universal-3.5 Pro

Reach for AssemblyAI when you need more than a transcript. Universal-3.5 Pro sits just behind Melia at 7.0% aggregate, and independently posts 6.99% WER on Pipecat's open voice agent benchmark, a harder and more conversational test set than clean read speech.

Keyterm prompting is the feature you will actually use. You hand the model a list of terms you expect and it biases toward them. Universal-3.5 Pro allows up to 1,000 keywords or phrases, six words maximum per phrase. On calls full of SKUs, drug names or your own oddly spelled brand, this is the difference between a searchable transcript and a useless one. The working call:

Python
Copy
import assemblyai as aai

aai.settings.api_key = "YOUR_API_KEY"

config = aai.TranscriptionConfig(
    speech_models=["universal-3-5-pro"],
    speaker_labels=True,
    keyterms_prompt=["DevToolLab", "Nova-3", "WER"],
)

transcript = aai.Transcriber(config=config).transcribe("meeting.mp3")

if transcript.status == aai.TranscriptStatus.error:
    raise RuntimeError(transcript.error)

for utterance in transcript.utterances:
    print(f"Speaker {utterance.speaker}: {utterance.text}")

The same request over plain REST, if you would rather not add a dependency:

Bash
Copy
curl -X POST https://api.assemblyai.com/v2/transcript \
  -H "Authorization: $ASSEMBLYAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "audio_url": "https://assembly.ai/wildfires.mp3",
    "speech_models": ["universal-3-5-pro"],
    "language_detection": true
  }'

Pricing is $0.21 per hour async and $0.45 streaming, with the older Universal-2 still at $0.15 if you do not need the newer model. Signup gives you $50 of credit without a card. One date for the calendar: the u3-rt-pro identifier auto-routes to universal-3-5-pro on 7 August 2026 and stops being accepted around 25 September 2026, so anything still pinning the old string needs updating this quarter.

The add-ons are where the bill gets away from you, because they stack additively on the base rate. Speaker diarization is $0.02 per hour on async but $0.12 on streaming. Medical mode adds $0.15, topic detection another $0.15, entity detection $0.08, translation $0.06. Enable four and you have roughly tripled your rate.

Deepgram Nova-3 and Flux

Deepgram competes on price and latency rather than top-line accuracy. Nova-3 monolingual is $0.0048 per minute pre-recorded, about $0.29 per hour, and $0.0077 streaming; the multilingual variant is $0.0058 and $0.0092. Those are pay-as-you-go numbers, and the Growth plan takes roughly 20% off for prepaid credits, dropping monolingual to $0.0042. New accounts get $200 of credit, the largest free allocation here.

Flux is the more interesting product. Deepgram calls it conversational speech recognition rather than ASR, and for once the distinction is real. Flux Multilingual went GA on 29 April 2026 with 10 languages and mid-call language switching. The difference is that end-of-turn detection lives inside the model instead of being bolted on as a silence timer. A timer waits for a fixed quiet period and then guesses the speaker is done, which is why so many agents cut people off mid-thought. Flux makes a model-based turn decision in under 400 milliseconds and emits it as an event you can subscribe to.

Flux runs on /v2/listen, not /v1/listen, and three parameters control it. eot_threshold (0.5 to 0.9, default 0.7) sets how sure the model must be before declaring the turn over. eager_eot_threshold lets you start generating an LLM response speculatively before it is certain. eot_timeout_ms (default 5000) is the hard silence fallback. The socket emits TurnInfo, EndOfTurn, EagerEndOfTurn and TurnResumed; that last one means the user started talking again, so throw away the draft response you were building.

Hit the endpoint directly before you write any application code:

Bash
Copy
wscat -c "wss://api.deepgram.com/v2/listen?model=flux-general-en&encoding=linear16&sample_rate=16000&eot_threshold=0.7" \
  -H "Authorization: Token $DEEPGRAM_API_KEY"

Flux English is $0.0065 per minute, Flux Multilingual $0.0078, both around 20% lower on Growth. Deepgram also sells a bundled Voice Agent API at $0.075 per minute standard or $0.163 advanced, wrapping ASR, the LLM, synthesis and turn handling into one billable stream, with bring-your-own-TTS variants at $0.065 and $0.122. Watch the meter on that one: it runs on WebSocket connection time, not speech time. Bundling costs several times what assembling the pieces yourself does, which is a fair trade for a prototype and a bad one at volume.

ElevenLabs Scribe v2

ElevenLabs arrived from the other direction: synthesis first, recognition bolted on later. Scribe v2 turned out to be competitive rather than a checkbox. Scribe v2 Realtime gives you roughly 150 millisecond first-partial latency across 90+ languages with automatic language detection, which puts it at the front of the low-latency pack.

Pricing is $0.22 per hour for batch and $0.39 per hour for realtime, with optional entity detection at $0.07 per hour and keyterm prompting at $0.05 per hour. Those rates followed a substantial cut in 2026, roughly 45% off speech-to-text and 55% off Flash synthesis, and they matter more than they look: $0.39 per hour is the cheapest published realtime rate in this comparison, undercutting AssemblyAI streaming at $0.45 and Deepgram Nova-3 streaming at about $0.46. The per-hour rate is also identical on every plan from the free tier up to Business at $990 a month, because the plans buy included volume rather than a lower unit price, so there is no penalty for evaluating on the cheapest tier.

The case for ElevenLabs is consolidation: recognition, synthesis and agents behind one vendor, one bill and one SDK. Flash and Turbo synthesis is $0.05 per 1,000 characters at roughly 75 millisecond latency, the higher quality Multilingual v2 and v3 voices are $0.10, and the bundled agent product runs $0.08 per minute of conversation, $0.16 under burst pricing.

The counter-argument: you are betting your whole audio stack on one vendor's pricing decisions, and ElevenLabs has restructured pricing more than once. It also does not publish what is behind Scribe v2, so you are trusting benchmark numbers rather than an architecture you can reason about.

OpenAI and Google

OpenAI's transcription models are the path of least resistance if your application already talks to the OpenAI SDK. The current lineup is gpt-transcribe for general file transcription, gpt-4o-transcribe-diarize when you need speaker labels, and whisper-1 when you specifically need word-level timestamps, translation or subtitle output. Published rates run from $0.003 per minute for the mini model through $0.0045 and $0.006 per minute for the standard options, up to $0.017 per minute for live transcription. Four lines of code get you a transcript:

Python
Copy
from openai import OpenAI

client = OpenAI()

with open("meeting.mp3", "rb") as audio_file:
    transcription = client.audio.transcriptions.create(
        model="gpt-transcribe",
        file=audio_file,
    )

print(transcription.text)

Setting stream=True on the same call turns it into a stream of transcript.text.delta events terminated by transcript.text.done, which is enough for a live-captioning UI without moving to a WebSocket. OpenAI also shipped GPT-Live in July 2026, a new generation of voice models that now powers ChatGPT Voice and shows up in the API as the live transcription endpoint. For full speech-to-speech agents, the Realtime models bill on audio tokens rather than minutes, at $32 per million input tokens and $64 per million output for the full model, or $10 and $20 for the mini variant. Token-based audio billing is harder to forecast than per-minute billing, so run a representative call through it before committing.

Google Cloud Speech-to-Text V2 is the default when your data already lives in GCP and compliance says it should stay there. Standard recognition is $0.016 per minute, roughly $0.96 per hour, which makes it the most expensive mainstream option on a straight rate comparison. Volume brings that down in published tiers rather than through a sales call: $0.010 per minute above 500,000 minutes a month, $0.008 above one million and $0.004 above two million. If a 24 hour turnaround is acceptable, dynamic batch drops to $0.003 per minute, about $0.18 per hour, which is the second cheapest hosted rate here behind Speechmatics Melia.

The Chirp model family, now headed by Chirp 3, is included at that same rate with no premium tier, and language coverage is the broadest of the big three clouds. Two billing mechanics are worth knowing before you model costs: every request is rounded up to the next whole second, and each audio channel bills separately, so a stereo recording with one speaker per channel costs double. The free allowance is 60 minutes a month with no expiry, plus the standard $300 in new-account GCP credit for 90 days.

The Open-Source Options

Self-hosting stopped being a compromise somewhere in the last eighteen months. The open models now win outright on throughput, and on accuracy they are close enough that the remaining gap is smaller than the gap between clean and noisy audio.

Whisper remains the baseline. It is MIT licensed for both code and weights, trained on 680,000 hours of audio, and covers 99 languages, which is still more than any hosted commercial model offers. Nobody runs the reference implementation in production any more, though. faster-whisper reimplements it on CTranslate2 and is the standard choice on NVIDIA hardware, whisper.cpp covers CPU and Apple Silicon, and large-v3-turbo gives you most of the accuracy of large-v3 at a fraction of the compute for English work.

NVIDIA Parakeet TDT 0.6B v3 wins on raw throughput. Summaries of the Open ASR Leaderboard in July 2026 put it at 6.32% average word error rate with an RTFx of 3332.74, meaning it transcribes over three thousand seconds of audio per second of wall clock on an A100, and it handles up to 24 minutes of audio in a single pass. To put that number in perspective, the same leaderboard measures Whisper large-v3 at an RTFx of 68.56. The catch is language coverage: Parakeet v3 handles 25 European languages, so for Thai, Arabic or Japanese you are back to Whisper. The license is CC-BY-4.0, which permits commercial use with attribution.

If accuracy matters more than speed and your workload is English, NVIDIA Canary-Qwen-2.5B and IBM Granite Speech 4.1 sit at the top of the open English rankings at 5.63% and 5.33% average word error rate respectively, both trading throughput for that accuracy. Granite is Apache 2.0, which is the cleanest license in this group.

For edge and embedded work, Moonshine from Useful Sensors is the one to look at. It pairs a lightweight audio frontend with a sliding-window transformer encoder designed specifically for streaming rather than for fixed-length chunks, runs up to five times faster than Whisper in live scenarios, and deploys to Raspberry Pi, iOS, Android and plain Linux. English models are MIT licensed; other languages fall under a separate community license, so check before you ship.

Two more worth knowing about: Kyutai STT offers 1B and 2.6B streaming-native models for English and French at around 6.40% word error rate, and Mistral's Voxtral Mini Realtime covers 13 languages under Apache 2.0. At the far end of the coverage spectrum, Meta's Omnilingual ASR release claims support for over 1,600 languages, which matters enormously if your users speak something no commercial vendor has ever priced.

Here is the local pipeline that produced the result in the opening paragraph. It runs on a laptop with no GPU and no API key:

Python
Copy
from faster_whisper import WhisperModel

# int8 keeps this comfortable on a laptop CPU; use compute_type="float16" on a GPU.
model = WhisperModel("base.en", device="cpu", compute_type="int8")

segments, info = model.transcribe(
    "sample.wav",
    beam_size=5,
    vad_filter=True,
    initial_prompt="Vocabulary: DevToolLab, WER, ASR.",
)

print(f"language={info.language}  duration={info.duration:.1f}s")
for segment in segments:
    print(f"[{segment.start:6.2f}s -> {segment.end:6.2f}s] {segment.text.strip()}")

Install it with pip install faster-whisper, point it at any 16 kHz mono WAV, and the first run downloads the model automatically. On the test file, inference took 0.6 seconds for 9.2 seconds of audio, roughly 15 times faster than real time, on CPU alone. The initial_prompt argument is the open-source equivalent of keyterm prompting, and it is what turned "Dev Tulab" into "DevToolLab". Without it the model has no idea your product name exists; with it, one short vocabulary line fixes the class of error that makes transcripts unsearchable.

The Voice Side: Text-to-Speech

Synthesis is what users actually judge you on. They never see a transcription slip, but they hear a robotic voice and they feel every pause before it starts speaking. Deepgram Aura-2 is $0.030 per 1,000 characters and sits in the same API as your recognition, ElevenLabs Flash and Turbo are $0.05 with the expressive Multilingual v2 and v3 voices at $0.10, Cartesia sells Sonic on latency above all else, and OpenAI's tts-1 and tts-1-hd work out to $0.015 and $0.030 per 1,000 characters.

Treat the published latency figures with suspicion. Vendors quote as low as 40 milliseconds for Sonic and 75 for ElevenLabs Flash, while independent time-to-first-audio measurements over real networks land near 188 and 264 milliseconds respectively. Both can be honest because they measure different things, and neither predicts what your users will hear from your region, so measure it from the network you will actually deploy on.

Open-source synthesis is better than most developers expect. Kokoro is an 82 million parameter Apache 2.0 model that runs comfortably on CPU, Chatterbox from Resemble AI is MIT licensed and benchmarks competitively against commercial products, Orpheus from Canopy Labs is built on Llama with unusually good prosody, and Piper remains the pragmatic pick for Raspberry Pi and CPU-only deployments.

What the Benchmark Tables Do Not Tell You

Published word error rates come from clean, well-recorded read speech. Production audio has background noise, overlapping speakers, accents, telephony compression and domain jargon. A provider showing 5% on a benchmark can easily deliver 15 to 20% on a difficult real-world call. The only benchmark that matters is 30 minutes of your own worst audio run through the top three candidates, and it takes an afternoon to do.

Streaming billing is the second trap. AssemblyAI bills streaming on WebSocket session duration, open to close, not on audio actually sent. Idle time counts. If your application opens a socket when the page loads and closes it when the user leaves, you are paying for the silence in between, and your bill will bear no resemblance to your audio minutes. Open the connection when speech starts and close it when the turn ends.

Multichannel audio is the third. Stereo files with one speaker per channel are billed as two channels of audio, which doubles the hours. That is often still the right choice, because per-channel transcription beats diarization for accuracy when you control the recording, but it needs to be in the cost model rather than a surprise.

Finally, the add-ons stack additively. It is entirely possible to start from the cheapest base rate in this comparison and end up with the most expensive bill by enabling diarization, entity detection, PII redaction and topic detection on top of it. Price the configuration you will actually ship, not the headline number.

How to Choose and Wire Up a Speech Pipeline

The sequence that gets you from nothing to a working, costed pipeline in an afternoon:

1. Collect 30 minutes of your genuinely worst audio. Not the clean demo file. This evaluation set is the highest-value thing you will build in the whole process.
2. Write down the ten to twenty terms that must be correct. Product names, SKUs, drug names, anything whose misspelling makes a transcript unsearchable.
3. Run the free baseline. Transcribe the set locally with faster-whisper using the code above. If open-source output is good enough, you have just removed a vendor and a recurring bill.
4. Test two or three hosted candidates on the same files using the free credits, $200 at Deepgram and $50 at AssemblyAI, feeding your term list into keyterm prompting wherever it is supported.
5. Score on the terms that matter, not on aggregate WER. This ranking often disagrees with the published leaderboard, and yours is the one that reflects your product.
6. Test turn detection separately if you are building an agent. Pause mid-sentence, then continue. A silence-timer pipeline cuts you off; a model-based one such as Flux does not.
7. Model the real cost using connection-open duration for streaming plus the add-ons you will actually enable, then compare it against a GPU instance running Parakeet or Whisper before signing anything annual.

Which One Should You Actually Use

For the most accurate transcript per dollar on recorded audio, use Speechmatics Melia-1: it leads the most recent independent test and, from $0.129 per hour, is also the cheapest hosted batch rate here. If the transcript feeds something downstream, use AssemblyAI Universal-3.5 Pro, where a 1,000 term keyterm budget, speaker labels and the audio intelligence stack in one API outweigh the small accuracy gap, provided you price the add-ons deliberately.

For voice agents, use Deepgram Flux, because model-integrated end-of-turn detection under 400 milliseconds solves a problem no amount of transcription accuracy will fix. If you only need plain streaming transcription without the turn logic, ElevenLabs Scribe v2 Realtime is the cheapest published rate at $0.39 per hour. If you would rather have one vendor for the whole audio loop, ElevenLabs Scribe v2 plus Flash synthesis is coherent and fast, at the cost of concentrating your risk. And if you are already deep in a cloud or an SDK, the incumbent usually wins: OpenAI and Google Speech-to-Text V2 are both good enough that saved integration time beats a fraction of a cent per minute.

If your volume is high, your data is sensitive, or your budget is zero, self-host instead. Parakeet TDT 0.6B v3 for European-language throughput, Whisper large-v3 through faster-whisper for anything multilingual, Moonshine for edge devices. On one GPU these run fast enough that hosted APIs stop being the obvious default.

Conclusion

The accuracy race between the top hosted providers has narrowed to about two and a half percentage points of aggregate word error rate, which for most applications sits inside the noise floor of your own audio quality. Everything else is now the real differentiator: how a model decides a human has stopped speaking, whether you can tell it your vocabulary in advance, and what the meter is actually counting when it bills you.

Give the open models a serious look before signing anything. Parakeet transcribes three orders of magnitude faster than real time on a single GPU, Whisper still covers more languages than anyone selling an API, and a laptop CPU handled nine seconds of audio in six tenths of a second in the test that opened this article. Start there, measure against your own worst recordings, and pay for a hosted API only once you know which problem you are paying it to solve.

Related DevToolLab Tools

• Speech to Text - transcribe live microphone audio in the browser to sanity-check a recording before you send it to a paid API.
• Microphone Test - check your input device's waveform, volume level and sample rate, since most bad transcripts start as bad audio.
• WebSocket Tester - connect to a streaming transcription endpoint such as Deepgram's /v2/listen and watch the raw turn events arrive.
• SRT to VTT Converter - turn transcription output into WebVTT captions for HTML5 video with normalized timestamps.

Related Guides

• Best LLM Gateways in 2026 - the routing layer that sits between your transcript and the model that reasons about it
• Best AI Agent Frameworks in 2026 - what to build around a voice pipeline once transcription is working
• Top Local LLM Tools and Models - the same self-hosting argument applied to the language model half of a voice agent