Best dictation APIs in 2026: 9 options compared for developers

This guide is for developers adding dictation to their own product. If you want an app to dictate into, this isn't that list. If you want the API behind a mic button in your app, keep reading.

Most "best speech-to-text API" roundups rank vendors on word error rate and stop there. That misses what dictation users care about. Someone who holds a key, says "um, send it to Priya, no, to Raj," and lets go wants a sentence they can send. They don't want a transcript to clean up by hand.

So this comparison scores nine options on what decides a dictation feature: whether the API returns finished text, how fast that text comes back, whether you can steer the output per request, and what it costs. We built one of these APIs, and we'll say plainly where the others are the better pick.

Update, October 2026: The Dictation API now accepts finished recordings up to 20 minutes (256 MB, including MP3, M4A, AAC, Ogg/Opus, FLAC, and WebM) on POST /v1/transcribe. The 120-second limit still applies when you upload while recording through /v1/transcribe/live or the Python SDK. A new rewrite_mode (fast or smart) gives you more control over formatting, and llm_instruction is no longer capped at 2,048 characters. Details in the Dictation API docs.

Dictation API vs speech-to-text API

A speech-to-text API returns a transcript of what was said, filler words and false starts included. A dictation API returns finished text: fillers removed, self-corrections resolved, punctuation and formatting applied, ready to drop into a text field.

You can get from one to the other by adding an LLM cleanup pass. The rest of this post is about who does that pass for you, and how well.

Six things to evaluate (and one that doesn't matter)

These are the criteria we used to compare the options below. For test scripts and scoring for each one, see our guide to evaluating a dictation API.

1. Time to finished text. Dictation blocks the UI. Measure wall-clock time from key release to final text in the field, not time to first partial.
2. Where cleanup happens. If the API doesn't clean up the transcript, you're making a second inference call in the most latency-sensitive path in your product.
3. Per-request steering. Can you pass an instruction with each request ("format as a bulleted list", "keep code identifiers verbatim"), or is formatting fixed at the account level?
4. Accuracy on the words that matter. Proper nouns, product names, drug names, and IDs. Overall WER hides these.
5. Language coverage at both layers. Transcription languages and cleanup languages are often different lists. Check both.
6. Request shape and limits. Clip-length ceilings, accepted audio formats, SDK requirements, and how the API behaves under bursty traffic. Check whether the ceiling differs between a finished upload and a live upload.

The one that doesn't matter much: streaming partials. Watching words appear while you talk looks good in a demo, but for push-to-talk dictation users mostly care about the final text.

The best dictation APIs, compared

Prices are list prices from each vendor's public pricing page as of October 2026. Check them before you budget.

The 9 dictation APIs, one by one

1. AssemblyAI Dictation API

The AssemblyAI Dictation API is built for one job: turning a short spoken utterance into text a user can send. Each response includes the verbatim transcript (text) and the finished version (llm_response), so you can show the clean text and keep the raw one for debugging or undo.

What you get, per the Dictation API docs:

• Up to 20 minutes of audio per finished recording over HTTP, or 120 seconds when you upload while the user is still speaking, with typical short clips returned in under one second.
• Per-request output steering with llm_instruction, for example "Format as a bulleted task list. Keep names verbatim."
• A rewrite_mode switch: fast (default) for the lowest latency, smart for detailed formatting instructions such as spoken punctuation.
• Recognition steering before cleanup: stt_prompt describes what the audio is about (up to 6,000 characters), and keyterms_prompt lists exact spellings to favor (up to 100 terms). See prompting and keyterms.
• A plain HTTP endpoint with no SDK required. It accepts WAV and raw PCM when you upload while recording, and finished recordings in WAV, PCM, MP3, M4A, AAC, Ogg/Opus, FLAC, or WebM.
• Transcription in 32 languages.

It runs on Universal-3.5 Pro, the same flagship model behind our pre-recorded speech-to-text. Pricing is $0.62/hr, all-in, on the pricing page.

If you'd rather own the cleanup step yourself, the Sync API returns the verbatim transcript on the same synchronous request shape. Our Sync API vs Dictation API comparison covers when each one fits.

Where it's weaker: it's built for single-speaker dictation, not hour-long multi-speaker recordings; for those, use the pre-recorded API. Medical Mode isn't available on the Dictation API, so clinical teams steer drug names and terms with prompts and keyterms instead. Our clinical dictation guide walks through that setup.

"The speed difference is immediately noticeable — our users see their conversations transcribed almost instantaneously. It feels so much more responsive than what we were using before."

— Jonathan Kim, Software Engineer, Granola

2. Deepgram

Deepgram's dictation feature converts seven spoken commands into punctuation: period, comma, colon, question mark, exclamation mark, new line, and new paragraph. You turn it on with dictation=true, and it needs punctuate=true as well.

The docs list Flux English as the supported model, for pre-recorded and streaming audio. That's useful if your users already speak their punctuation. It doesn't rewrite the transcript into finished prose, so filler removal and formatting are still yours to build, and it's English-only.

3. ElevenLabs Scribe v2 Realtime

Scribe v2 Realtime is a streaming model. ElevenLabs advertises about 150ms latency and 90+ languages, and lists it at $0.39/hr on its API pricing page (batch Scribe v2 is $0.22/hr).

It returns a verbatim transcript. For dictation you'd add your own LLM cleanup call, which brings back the second round trip that matters most in a push-to-talk flow.

4. OpenAI transcription

OpenAI's speech-to-text API recommends gpt-transcribe for recorded audio and accepts files up to 25 MB. You can pass a prompt plus keywords and languages to guide recognition, and there's a separate realtime path for live audio.

Output is verbatim. Cleanup means a second model call, which you write, prompt, and maintain. If your stack already runs on OpenAI, that may be an acceptable trade.

5. Gladia Audio-to-LLM

Gladia's Audio-to-LLM runs your own prompts on a pre-recorded transcript after transcription finishes. It routes through OpenRouter, so you pick the model, and you pay per million tokens at rates that vary by model. That's on top of transcription, which starts at $0.61/hr on Gladia's Starter plan (pricing).

It's a good fit for turning recordings into summaries or structured fields. It's a poor fit for interactive dictation, because it works only on pre-recorded audio and waits for the full pipeline to finish.

6. Google Cloud Speech-to-Text and Azure Speech

Google Cloud Speech-to-Text runs on Chirp 3, supports 85+ languages and variants, and offers synchronous, asynchronous, and streaming recognition. It includes automatic punctuation (beta), speech adaptation for rare words, and spoken-number conversion. The V2 API lists at $0.016 per minute.

Azure Speech covers a similar footprint: a broad language list and batch or real-time modes. Neither has a dictation-specific output layer, so cleanup is a second step either way. Pick these when your company already has the cloud contract and the security review done.

7. AWS Transcribe Medical

AWS Transcribe Medical has a dedicated medical dictation mode for clinician-dictated notes. Primary care is supported in batch and streaming. Cardiology, neurology, oncology, radiology, and urology are streaming-only. You can add custom medical vocabularies to improve accuracy on specialty terms.

It returns a transcript, not a finished note, so formatting and cleanup are still on you.

8. Speechmatics

Speechmatics supports 55+ languages, real-time and batch transcription, and says real-time results arrive in under one second. Its main differentiator is deployment: it runs on-device, on-prem, or in the cloud. It also markets a Medical Model for ambient scribe and dictation that it says cuts errors on key terms by up to 50%.

Like most options here, it returns a transcript and leaves cleanup to you.

9. Web Speech API

The Web Speech API is free and built into the browser. By default it sends audio to a recognition service provided by the user's platform, with an on-device option in some browsers. Support and quality vary by browser, so check MDN's compatibility table before you rely on it.

It's the fastest way to get a working mic button in a prototype. It won't give you consistent results across your users' browsers, and it returns verbatim text.

Free dictation API options

If you need dictation at zero cost, the Web Speech API is the only option here that's free at any volume, with the browser-support caveats above. Google Cloud offers new customers up to $300 in free credits, and Gladia gives new accounts 50€ in credits.

AssemblyAI has a free sign-up, so you can test the Dictation API on your own audio before you pay anything. For a production feature, budget for a paid API: free browser recognition is hard to support once real users on different browsers start filing bugs.

Building a Wispr Flow alternative: which API?

Wispr Flow and Superwhisper are dictation apps people install and talk into. If you're searching for a Wispr Flow alternative because you want that experience inside your own product, you need a dictation API underneath it.

Apps like these need a short-clip, low-latency request, cleanup that removes fillers and resolves "no, I mean" corrections, and the ability to adapt output to the app the user is typing into. That maps directly to a dictation API with per-request instructions. With the AssemblyAI Dictation API, you'd send the active app's context in llm_instruction ("this is a Slack message, keep it casual") and product names in keyterms_prompt. Our tutorial for building a dictation app shows the hotkey flow end to end.

Which is better for dictation, Wispr Flow or Superwhisper? That's a question for end users choosing an app, and it depends on platform and workflow. For developers, the more useful question is which API gives you finished text fast enough that your own app feels like either of them.

What building it yourself costs

On per-hour pricing, a dedicated dictation API and a DIY stack of transcription plus an LLM land in a similar range. The cost difference shows up in engineering time:

• Two sequential inference calls in your most latency-sensitive path.
• A cleanup prompt you maintain as models change.
• Two sets of rate limits and failure modes.
• Quality tuning across accents, jargon, and edge cases while keeping the round trip under a second.

Teams that build it themselves tell us the infrastructure is the easy part. Most of the effort goes into output quality. We break down the trade in Dictation API vs speech-to-text + LLM.

The failure mode nobody budgets for

Cleanup improves how text reads. It can't fix what was misheard.

If recognition turns "metoprolol" into "met a pro lol," a good cleanup model gives you a confident, well-punctuated, correctly formatted wrong sentence. A raw transcript at least looks broken. Polished output hides the error, and the user sends it.

The fix sits upstream of cleanup. Steer recognition with context prompts and keyterms so the right word is transcribed in the first place. Our post on how dictation cleanup works goes deeper on where each layer helps.

Your first call, end to end

Here's a complete request to the AssemblyAI Dictation API. Pass your API key in the Authorization header as the raw key, with no Bearer prefix.

curl -X POST https://dictation.assemblyai.com/v1/transcribe/live \
  -H 'Authorization: <YOUR_API_KEY>' \
  -F 'config={"llm_instruction": "Format as a bulleted task list. Keep names verbatim."};type=application/json' \
  -F 'audio=@clip.wav;type=audio/wav'

The response carries both versions of the text:

{
  "text": "Um, so, can you send me the Q3 numbers before the meeting tomorrow? Thanks.",
  "llm_response": "So, can you send me the Q3 numbers before the meeting tomorrow? Thanks.",
  "confidence": 0.95,
  "words": [...],
  "audio_duration_ms": 5200,
  "session_id": "...",
  "request_time_ms": 850
}

Send config={} to use the default cleanup. There is no switch that turns the rewrite off, and setting llm_instruction to null keeps the default cleanup, so read text when you only want the verbatim transcript.

Which one to pick

• You're shipping dictation as a product feature: use a dedicated dictation API for sub-second finished text and per-request control. That's what we built the AssemblyAI Dictation API for.
• You need verbatim streaming across many languages: ElevenLabs Scribe v2 Realtime or a hyperscaler, with cleanup you add yourself.
• Your company is committed to Google, Azure, or AWS: use their speech API and reuse the security review and spend commitment you already have.
• You need on-prem or on-device recognition: look at Speechmatics.
• You're building a weekend prototype: the Web Speech API is free and takes minutes.
• You're turning recordings into structured output, not live dictation: an async pipeline such as Gladia Audio-to-LLM or AssemblyAI's pre-recorded API is the better shape.

Where dictation APIs go next

Accuracy and latency are converging across the top vendors. The next differences will be in control: which model does the rewriting, how much product context reaches recognition, and whether an instruction can keep the user's own voice instead of flattening it into generic prose. On the AssemblyAI Dictation API that control now includes a smart rewrite mode, which follows detailed formatting instructions more reliably than the default fast tier at the cost of some latency.

Developers building dictation into coding tools already want this. They need to dictate to coding agents without file names and function names getting "corrected." When you evaluate a dictation API, spend less time on benchmark tables and more time testing how much you can control in each request.

Frequently asked questions

What is the best dictation API in 2026?

The best dictation API for most developers is one that returns finished text, not just a transcript, in under a second. The AssemblyAI Dictation API does that in one call, returning cleaned text and the verbatim transcript together for $0.62/hr. If you need on-prem deployment or are tied to one cloud, Speechmatics or your cloud provider's speech API may fit better.

Is there a free dictation API?

The Web Speech API is free and built into browsers, but support and quality vary by browser and it returns verbatim text. Paid APIs often have free credits or free sign-up, including Google Cloud (up to $300 for new customers), Gladia (50€), and AssemblyAI. For production features, a paid API gives you consistent results across users.

What's the best API to build a Wispr Flow alternative?

To build a Wispr Flow-style feature, you need an API that returns finished text from short clips fast enough for push-to-talk. The AssemblyAI Dictation API is built for this. It removes fillers, resolves self-corrections, and accepts a per-request instruction so output can match the app the user is typing into.

Does Deepgram have a dictation API?

Deepgram offers a dictation feature that converts spoken punctuation commands, such as "comma" and "new paragraph," into punctuation marks. It requires dictation=true and punctuate=true, and the docs list English on the Flux model. It doesn't rewrite transcripts into finished text, so cleanup is a separate step.

Should I use a synchronous, streaming, or async API for dictation?

Use a synchronous API for push-to-talk dictation: the user speaks a short clip, releases the key, and gets finished text in one response. Streaming suits live captions where partial words need to appear on screen, and async suits long multi-speaker recordings. The AssemblyAI Dictation API and Sync API both use the synchronous shape, for clips from a few seconds up to 20 minutes.

How do I improve dictation accuracy for jargon and product names?

Steer recognition before cleanup runs, because cleanup can't fix a misheard word. With the AssemblyAI Dictation API, pass context in stt_prompt and exact spellings in keyterms_prompt (up to 100 terms). Then use llm_instruction to tell the cleanup step to keep names and identifiers verbatim.