The short answer (August 2026): OpenAI Whisper is a free, open-source speech-to-text model released under the MIT license that runs entirely on your own machine at no cost. Install it with pip install -U openai-whisper, point it at any audio file, and get a transcript in seconds. If you prefer a managed setup, the OpenAI API exposes the same model as whisper-1 at $0.006 per minute with no subscription required. Six model sizes, from the tiny 39M-parameter build to the 1.55B-parameter large, let you match accuracy and speed to your available hardware.
Last verified: August 1, 2026, against official docs and pricing pages.
What Whisper Is and What It Costs
Whisper is a general-purpose speech recognition model trained on 680,000 hours of multilingual audio. OpenAI released the weights and code in 2022; the package on PyPI (openai-whisper, version 20250625) is MIT-licensed, meaning you can use it in commercial products without paying royalties.
Running locally is free in the operational sense. You pay for your own hardware electricity or cloud VM time, but there are no API calls or usage meters. The OpenAI-hosted whisper-1 API costs $0.006 per minute of audio, billed per second with no minimum charge and no monthly seat fee.
For one-off personal use, local is almost always cheaper. For serverless functions, CI pipelines, or teams without GPU access, the API often makes more sense once you factor in the engineering cost of running inference infrastructure.
Installing Whisper Locally
You need Python 3.8 or newer and ffmpeg on your system PATH. Install ffmpeg first, then the Python package.
ffmpeg on Ubuntu/Debian:
sudo apt update && sudo apt install ffmpeg
ffmpeg on macOS (Homebrew):
brew install ffmpeg
ffmpeg on Windows (Chocolatey):
choco install ffmpeg
Then install Whisper:
pip install -U openai-whisper
If the install fails while building tiktoken, you also need Rust. Check the official README for the exact error message and fix. Once installed, the whisper CLI command is available globally in your Python environment.
Picking the Right Model
Whisper ships six models. Turbo is the recommended default: it runs roughly 8x faster than the large model while requiring only 6 GB of VRAM, making it the practical choice for most machines.
| Model | Parameters | VRAM required | Speed vs. large | Best for |
|---|---|---|---|---|
| tiny | 39M | ~1 GB | ~10x faster | CPU-only machines, rough drafts |
| base | 74M | ~1 GB | ~7x faster | CPU-only with slightly better accuracy |
| small | 244M | ~2 GB | ~4x faster | Laptops with integrated GPU |
| medium | 769M | ~5 GB | ~2x faster | Mid-range GPUs, good accuracy |
| large | 1550M | ~10 GB | 1x (baseline) | Maximum accuracy, high-end GPU |
| turbo | 809M | ~6 GB | ~8x faster | Recommended default; best balance |
For English-only audio, the .en suffix variants (tiny.en, base.en, small.en, medium.en) trade away multilingual capability for slightly better accuracy on English content. Whisper supports 98 languages total; omit the language flag and it auto-detects from the first 30 seconds of audio.
Running entirely on CPU is possible. On a modern laptop without a GPU, expect transcription to take roughly as long as the audio itself. An Apple Silicon Mac with the MPS backend is noticeably faster. An NVIDIA GPU with CUDA is the fastest local option.
Transcribing from the Command Line
After install, whisper is available globally. The simplest call:
whisper audio.mp3
This writes five output files to the current directory: audio.txt (plain text), audio.vtt (WebVTT subtitles), audio.srt (SubRip subtitles), audio.tsv (tab-separated with timestamps), and audio.json (full segment data with confidence scores). The default model is turbo.
Specify a model:
whisper interview.mp4 --model turbo
Get only one output format:
whisper meeting.m4a --model turbo --output_format srt
Set the language explicitly (faster and more accurate than auto-detect):
whisper lecture.wav --model small --language French
The --language flag accepts language names or two-letter ISO codes. Specifying the language skips the auto-detection step and improves accuracy on accented speech.
Transcribing in Python
import whisper
model = whisper.load_model("turbo")
result = model.transcribe("audio.mp3")
print(result["text"])
load_model downloads and caches the weights on first run. Load the model once and reuse it across files; reloading per file multiplies startup time unnecessarily.
To get segment-level timestamps:
model = whisper.load_model("turbo")
result = model.transcribe("audio.mp3")
for segment in result["segments"]:
start = segment["start"]
end = segment["end"]
text = segment["text"]
print(f"[{start:.1f}s - {end:.1f}s] {text}")
For word-level timestamps, add word_timestamps=True to the transcribe() call. Each segment dictionary then includes a words list with per-word start, end, and probability values.
Using the OpenAI API
If you need transcription in a serverless function, a cloud pipeline, or any environment where installing a GPU runtime is impractical, the hosted API is the practical alternative. See our guide on building AI agents if you want to wire transcription into a larger automation.
from openai import OpenAI
client = OpenAI() # reads OPENAI_API_KEY from environment
with open("audio.mp3", "rb") as audio_file:
transcription = client.audio.transcriptions.create(
model="whisper-1",
file=audio_file,
)
print(transcription.text)
The API accepts mp3, mp4, mpeg, mpga, m4a, wav, and webm files up to 25 MB per request. At $0.006 per minute, a one-hour interview costs $0.36. Files larger than 25 MB need to be split before sending.
Split a long file with ffmpeg into 10-minute chunks:
ffmpeg -i interview.mp3 -f segment -segment_time 600 -c copy part%03d.mp3
Then loop over the parts and join the text fields.
OpenAI's documentation now also highlights gpt-transcribe as a newer option for some transcription tasks; whisper-1 remains the direct Whisper model on the API.
Handling Large Files and Batch Jobs
Whisper processes audio in 30-second windows internally. For long local files, pass them whole on the command line and Whisper handles segmentation automatically. You only need to pre-split when hitting the 25 MB API constraint.
For batch transcription of many files:
import whisper
from pathlib import Path
model = whisper.load_model("turbo")
for audio_path in Path("recordings/").glob("*.mp3"):
result = model.transcribe(str(audio_path))
output_path = audio_path.with_suffix(".txt")
output_path.write_text(result["text"])
print(f"Done: {output_path}")
Load the model once outside the loop. Each transcribe() call reuses the same loaded weights.
For very large batches (hundreds of files), consider running on a GPU cloud instance. At roughly 8x real-time speed, turbo processes an hour of audio in under 8 minutes on a decent NVIDIA GPU.
FAQ
Does Whisper run on a Mac with Apple Silicon?
Yes. Whisper uses PyTorch's MPS (Metal Performance Shaders) backend on Apple Silicon automatically once you install PyTorch normally. Turbo and small are practical sweet spots on M-series Macs without dedicated VRAM constraints.
How accurate is Whisper on noisy or accented audio?
Whisper was trained on diverse real-world audio including podcasts and lectures, so it handles moderate background noise and a wide range of accents better than most older engines. Heavily degraded audio (echo, crowd noise, very low bitrate phone recordings) will still produce errors. Turbo and large are the most robust model choices for difficult audio.
Can Whisper identify who is speaking?
Whisper does not output speaker labels. For speaker diarization, combine Whisper's output with a separate library such as pyannote.audio, or use the OpenAI API's gpt-4o-transcribe-diarize model, which handles diarization natively but is a different product from Whisper.
Is my audio sent to OpenAI when I run Whisper locally?
No. The local package runs entirely on your machine. Audio files never leave your system. Only the API route (whisper-1) transmits audio to OpenAI's servers, which is relevant for sensitive recordings subject to confidentiality obligations.
What if I need subtitles with exact timing?
Use --output_format srt or --output_format vtt from the CLI. Both formats include start and end timestamps for every segment. For tighter control over segment length, add --max_line_width and --max_line_count flags to limit subtitle line length.
Guides like this run three times a week in AI Weekly, free, read by 40,000+ practitioners.