OpenAI's Whisper is a frontier ASR model anyone can host. For most developers the question is no longer which model but which hosted API gives Whisper-quality transcription without a bill — no GPU instance, no CUDA drivers, no Python audio dependency hell. Here's how Groq, Deepgram, and AssemblyAI compare on real free-tier ceilings, per-hour cost, and the trade-offs you hit as traffic grows. Every number links back to the provider's own docs.

The 30-second answer

"Free" comes in two shapes: a genuine free tier (a standing quota, no card — Groq and, since 2026, AssemblyAI) and signup credits (a one-time wallet spent at paid rates — Deepgram's $200). For reference, the official OpenAI Whisper API is $0.006/min ($0.36/hr) with no free tier — a real workload (1,000 podcast hours/month) is $360, which is why the free-tier race matters.

Groq: the only true free tier

Groq runs Whisper on its LPUs with a real, no-card free tier. Two models: whisper-large-v3 ($0.111/hr paid, highest accuracy) and whisper-large-v3-turbo ($0.04/hr, distilled, ~8× faster, small accuracy drop on long audio). Both are multilingual (99+ languages) with a separate translation endpoint; minimum billed length is 10 seconds. The free-tier ceiling is unusually generous:

• 20 requests/minute, 2,000 requests/day
• 7,200 audio seconds/hour (2 hours of audio every hour)
• 28,800 audio seconds/day (8 hours of audio every day)
• 25 MB max file size (100 MB on the paid Dev tier)

Eight hours of transcription per day, every day, no card or expiry — enough to run a real podcast tool or a daily meeting-notes app indefinitely. Groq is OpenAI-compatible on this endpoint:

curl https://api.groq.com/openai/v1/audio/transcriptions \
  -H "Authorization: Bearer $GROQ_API_KEY" \
  -F "file=@meeting.mp3" \
  -F "model=whisper-large-v3-turbo" \
  -F "response_format=verbose_json"

from openai import OpenAI
client = OpenAI(base_url="https://api.groq.com/openai/v1", api_key=os.environ["GROQ_API_KEY"])

with open("meeting.mp3", "rb") as audio:
    result = client.audio.transcriptions.create(
        model="whisper-large-v3-turbo", file=audio,
        response_format="verbose_json", timestamp_granularities=["segment"])
print(result.text)

verbose_json returns segment-level timestamps for captions or search; response_format=text drops the envelope. Poor fit when: you need speaker diarization (Whisper doesn't predict speaker turns — layer pyannote.audio or pick Deepgram/AssemblyAI), long async jobs (every request is synchronous — chunk files over ~60 min with ffmpeg), or a production SLA (use the paid Dev tier).

We measured it: 160× realtime on the free tier

Everyone calls Whisper APIs "fast". We wanted a number, so we sent the same public-domain speech recording — a 4-minute address — to Groq's free tier and timed it end to end (2026-08-31, US machine, open harness):

160× realtime means an hour-long recording transcribes in about 22 seconds. For free.

Turbo is the sensible default — but not by a number we can defend

The two transcripts came back 2,081 and 2,082 characters — a one-character difference on four minutes of speech. Whatever you gain in speed, you give up nothing in output.

The speed gap is another matter, and we originally overstated how well we knew it. The 1.53 s and 1.85 s above are one run each. Repeating the test on 3 September 2026 with three runs per model, the same model on the same audio varied far more than the gap between the two models:

A single run of each model cannot establish a 21% difference when one model swings 106% against itself. On the 28-second clip large-v3 even came out ahead — the reverse of the ordering above. (Those runs went over a slower network than the 4-minute test, so read the spread rather than the absolute times.)

The practical advice is unchanged: whisper-large-v3-turbo is the sensible default unless the audio is unusually hard — heavy accents, overlapping speakers, poor recording — because it matches large-v3's output and is designed to be quicker. What we cannot honestly tell you is by how much. If that margin matters to your workload, measure it on your own audio over several runs; anyone quoting a precise percentage from one request, ourselves included until today, is quoting noise.

Accuracy held up too. A separate clip of the famous JFK line came back as: "And so my fellow Americans, ask not what your country can do for you, ask what you can do for your country." — verbatim.

Careful how you read anyone's realtime numbers

We first ran this with an 11-second clip and measured 7.3× realtime. Same API, same model, same machine — but a twenty-fold difference from the 160× above.

The reason is that a transcription request has fixed overhead — TLS handshake, upload, queueing — that doesn't shrink with the audio. On an 11-second clip that overhead is the measurement. On four minutes it's noise.

So: a realtime factor is meaningless without the clip length attached. If a vendor or a blog quotes one without saying what they transcribed, it tells you nothing. And practically — if your workload is lots of short clips rather than a few long ones, expect throughput far below any headline figure, because you pay that overhead every time.

Deepgram: the $200 production path

Deepgram hosts Whisper as Whisper Cloud alongside its own models (Nova-3, Nova-2, real-time Flux) behind one key, so you can A/B both. Every new account gets $200 credit, no card, with no fixed expiry — roughly 700 hours of Whisper to evaluate (concurrency capped at 5 streams on the free tier). Deepgram's real recommendation for new English builds is Nova-3: cheaper per minute, with built-in diarization, smart formatting, language detection, and first-class real-time streaming (Whisper is fundamentally batch). Whisper Cloud remains right if you specifically need Whisper's multilingual behavior or are benchmarking a model swap.

from deepgram import DeepgramClient, PrerecordedOptions
dg = DeepgramClient(os.environ["DEEPGRAM_API_KEY"])
with open("meeting.wav", "rb") as f:
    payload = {"buffer": f.read()}
options = PrerecordedOptions(model="whisper-large",  # or "nova-3"
    punctuate=True, diarize=True, smart_format=True)  # diarize is Nova-3 only
response = dg.listen.rest.v("1").transcribe_file(payload, options)
print(response.results.channels[0].alternatives[0].transcript)

Poor fit when: once the $200 runs out there's no free tier behind it; higher concurrency needs a paid plan; and Whisper Cloud is a compatibility product, not Deepgram's strategic priority.

AssemblyAI: the biggest free allowance, but no Whisper

AssemblyAI sells a layered speech-intelligence platform where transcription is the foundation and the value is what stacks on top — chapters, sentiment, entities, moderation, summarization — all in the same request. New accounts get a standing free allowance, no card: up to 185 hours of pre-recorded and 333 hours of streaming transcription. Note what changed — AssemblyAI no longer lists a Whisper model at all; the pricing page carries only Universal-3.5 Pro ($0.21/hr) and Universal-2 ($0.15/hr). (Verified 2026-09-01.) The reason to pick it over Groq is almost always that you also want those features — adding sentiment_analysis: true or auto_chapters: true to one call returns per-sentence sentiment, chapter headlines, named entities, IAB topics, and PII redaction. Reproducing that on Groq means a second LLM call and your own chaptering logic. The API is two-step (upload + poll):

import os, requests, time
headers = {"Authorization": os.environ["ASSEMBLYAI_API_KEY"]}

with open("meeting.mp3", "rb") as f:
    audio_url = requests.post("https://api.assemblyai.com/v2/upload",
        headers=headers, data=f).json()["upload_url"]

job = requests.post("https://api.assemblyai.com/v2/transcript", headers=headers,
    json={"audio_url": audio_url, "speech_model": "universal",  # or "whisper-streaming"
          "speaker_labels": True, "auto_chapters": True, "sentiment_analysis": True}).json()

while True:
    status = requests.get(f"https://api.assemblyai.com/v2/transcript/{job['id']}",
        headers=headers).json()
    if status["status"] in ("completed", "error"): break
    time.sleep(3)
print(status["text"])

Poor fit when: your contract or compliance actually mandates Whisper — AssemblyAI has dropped it, so use Groq or Deepgram Whisper Cloud instead. The two-step upload also adds latency versus Groq's single call.

Other ways to get free Whisper

• Self-host with faster-whisper or whisper.cpp — truly free at the margin on hardware you own, but you own the ops; rarely worth it below ~500 hours/month for a SaaS.
• Hugging Face Inference API — can call Whisper checkpoints, but aggressive free-tier rate limits and unpredictable latency make it notebook-only.
• Cloudflare Workers AI — hosts Whisper billed in neurons; very clean if your stack is already on Cloudflare.
• Official OpenAI Whisper API — $0.006/min, the reference price; least integration friction if you already have an OpenAI key.

Side-by-side spec sheet

Which one should you pick?

• Side project / hackathon / personal tool → Groq. No card, real free tier, fastest to first transcription.
• Need speaker diarization → Deepgram Nova-3 (production) or AssemblyAI (if you also need chapters/summary).
• Need Whisper specifically as a hosted swap → Deepgram Whisper Cloud, then evaluate Nova-3.
• Transcript + sentiment + chapters + entities in one call → AssemblyAI; the integration cost saved beats the higher per-hour rate.
• Real-time streaming for a voice agent → Deepgram Flux/Nova or AssemblyAI Universal Streaming (Groq is batch-only).
• Already on Cloudflare Workers → Cloudflare Workers AI Whisper.

Combining free Whisper with a free LLM

The real unlock is transcription plus an LLM pass. A free side-project stack: audio in via Groq whisper-large-v3-turbo; an LLM pass for summaries/action items via Groq Llama 3.3 70B, Cohere Command R+, or Together AI Free Tier Is Gone: What It Costs Now; and embeddings for search via Cohere Embed v3. Three free keys, zero cards, end-to-end speech-to-search.

FAQ

Is OpenAI's Whisper actually free?

The model weights are MIT-licensed and free to self-host. The OpenAI Whisper API ($0.006/min) is not free — no free tier, card required. "Free Whisper API" almost always means a third-party host with a free path in — which, since AssemblyAI retired its Whisper offering, means Groq or Deepgram.

Which Whisper API is most accurate?

Groq and Deepgram host the same whisper-large-v3 checkpoint (or a distilled variant), so raw accuracy on identical audio is comparable between them; real-world differences come from pre/post-processing and diarization. Groq gives the cleanest raw Whisper output, Deepgram adds post-processing that helps for English business audio. AssemblyAI is no longer in this comparison — its Universal models are a different architecture, not Whisper.

What's the difference between whisper-large-v3 and turbo?

Turbo is a distilled version — ~8× faster and cheaper, with a small WER gap that's only meaningful on long, noisy, or accented audio. Turbo is the right default; reach for large-v3 only when you've benchmarked turbo on your data and found it lacking.

Can I use the free tier commercially?

Groq permits commercial use within its published rate limits (the paid Dev tier lifts limits and adds SLA). Deepgram's signup credit and AssemblyAI's free allowance are both usable for any purpose. Re-read each provider's TOS before deploying — it changes.

How do I handle files larger than 25 MB on Groq?

Chunk before sending: ffmpeg -i input.mp3 -f segment -segment_time 600 -c copy chunk_%03d.mp3 splits into 10-minute pieces; transcribe each and concatenate. Groq's docs also recommend downsampling to 16 kHz mono, which shrinks the file and matches Whisper's training format.

Related Reads

• Groq Free API Tested: ~525 tok/s + What You Can Build — the LLM offering that pairs with Groq's Whisper endpoint.
• Cohere Free API: Embedding and Rerank for RAG — the embedding half of a free transcription-to-search pipeline.
• Together AI Free Tier Is Gone: What It Costs Now — another free LLM source for post-transcription summarization.
• Cloudflare Workers AI — also hosts Whisper, billed in neurons.
• Free AI APIs in 2026: We Tested 10, Four Now Want a Card — the wider context for which provider does what.
• Open Source Voice AI Agent: LiveKit vs Pipecat — the frameworks that wire this STT step into a live conversation.