How to Use Whisper: The Beginner's Guide (First Install, First Transcription, the Model-Size Rule, and the Faster-Whisper Lane)

CodexFuse Team · 2026-11-01T10:45:12.974Z · 11 min read

What is Whisper, exactly?

Whisper is the open-source speech-to-text model from OpenAI that turns spoken audio into written text — interviews, podcasts, lectures, voice memos — on your own computer, with no account and no per-minute fee. If you want to learn how to use Whisper, this is the whole idea: you install a Python package, point it at an audio file, and it prints a transcript you can save as subtitles, notes, or searchable text. (One quick note: "whisper" is also an English verb, and there are unrelated products like WhisperAI and MacWhisper — this guide is about the open-source model at github.com/openai/whisper, the one with 111,685 stars, released under the MIT license.)

Whisper is a general-purpose speech-recognition model — a transformer that maps audio to text. It knows 98 languages out of the box, and it can transcribe, translate, and even detect the spoken language. The family tree is worth getting straight once: openai-whisper is OpenAI's reference Python package and command-line tool; faster-whisper is SYSTRAN's independent reimplementation that runs the same model weights much faster; and the whisper-1 API was the hosted pay-per-minute endpoint — which, as of 2026, is officially deprecated and shuts down on February 26, 2027, replaced by gpt-transcribe. This guide covers all three lanes so you pick the right one on purpose. If you need the reverse direction — text into speech — the offline text-to-speech guide covers Piper, Whisper's open-source voice sibling.

How do you install Whisper?

You install Whisper with one command: pip install -U openai-whisper. That is the canonical install line from the project's README, and it gives you both the whisper command-line tool and the Python API. The current PyPI release is 20250625 (June 2025) — Whisper uses date-based version numbers, so don't go looking for a version 2.0.

Before it runs, Whisper needs one system dependency: ffmpeg, which decodes your audio files. The official README lists the install line per platform:

There are two honest ways to get Whisper running. Pick by your use case, not by hype:

They are different installs, not two names for one thing. The reference package is simplest to learn; faster-whisper is what you switch to when speed matters — the full comparison is in the speed section below. One edge case from the README: on some systems the tiktoken dependency may need Rust to build a wheel, in which case installing setuptools-rust first fixes it.

How do you transcribe your first file?

Your first transcription is one line: whisper audio.mp3 --model turbo. Whisper downloads the model weights on first use, transcribes, and drops the results next to your audio file in several formats. turbo is the default model — you can type it explicitly while learning.

Here is the complete first-transcription arc, from a bare machine to a subtitle file:

1. Install Python 3.8 through 3.11 (the range the README says the package is compatible with).
2. Install ffmpeg with your platform's command from the table above.
3. Run pip install -U openai-whisper.
4. Confirm it worked: whisper --help should print the full option list.
5. Put an audio file in your working folder — mp3, wav, flac, m4a, or mp4 all work.
6. Run whisper audio.mp3 --model turbo and wait for the first download to finish.
7. Look at the plain-text transcript it wrote: audio.txt.
8. Open audio.srt — that is your ready-to-upload subtitle file.
9. Try a second run with --output_format vtt to see the web-caption variant.
10. Check audio.tsv if you want per-segment start and end times for editing.

By default Whisper writes all five output formats — txt, vtt, srt, tsv, and json — next to your input file. Pass --output_format to narrow it down, and --output_dir to choose where the files land.

How do you transcribe in another language — or translate it?

Whisper handles 98 languages, and you tell it which one you hear with --language: whisper japanese.wav --language Japanese. Language names are spelled out in English — the full list lives in the package's tokenizer file, and whisper --help points you there.

Translation into English is a separate task flag: whisper japanese.wav --model medium --language Japanese --task translate. Here is the gotcha the README spells out: turbo is not trained for translation. If you run --task translate with turbo, it silently returns the original language instead of English. For translation, step up to medium or large. Transcription accuracy also varies by language — English is the strongest; low-resource languages are weaker, so sanity-check the first few minutes before trusting a long transcript.

Which Whisper model size should you pick?

The model-size rule is simple: bigger models are more accurate but need more memory and run slower. Whisper ships six sizes, and the README's own speed measurements (relative speed transcribing English on an A100) tell the whole story:

Say the one-liner once: start with turbo. It is an optimized version of large-v3 that transcribes about eight times faster than large with only a minimal degradation in accuracy — for everyday transcription it is the best accuracy-per-minute you can get, and it runs fine on a CPU for short files. Move up to large only when turbo's errors bother you, and down to base or tiny only when the machine is too slow. English-only variants (tiny.en, base.en, small.en, medium.en) exist if you never transcribe other languages; large and turbo have no .en variants.

How do you make Whisper faster? The faster-whisper lane

When transcription feels too slow, switch engines: faster-whisper is SYSTRAN's reimplementation of Whisper on CTranslate2, and its README claims it is up to 4 times faster than openai/whisper for the same accuracy while using less memory. Their own benchmark on 13 minutes of audio with large-v2 on a GPU: the reference took 2 minutes 23 seconds; faster-whisper took 1 minute 3 seconds — and 17 seconds with batching turned on. Quantization (running the model in 8-bit) can push it further on both CPU and GPU.

The faster-whisper code is a little different — transcription runs as a generator, so the work happens as you iterate:

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="float16")
segments, info = model.transcribe("audio.mp3", beam_size=5)

for segment in segments:
    print("[%.2fs -> %.2fs] %s" % (segment.start, segment.end, segment.text))

Use device="cpu" on machines without a GPU — that is the whole point of the engine on a laptop. If you containerize the job, the Docker beginner guide shows the pattern for pinning a Python image and mounting your audio folder.

How do you use Whisper in Python?

The Python API is three lines: load the model, transcribe the file, read the text. This is the exact example from the current README:

import whisper

model = whisper.load_model("turbo")
result = model.transcribe("audio.mp3")
print(result["text"])

Note that it says "turbo", not "base" — older tutorials use base, but the current default and example is turbo. Under the hood, transcribe() reads the whole file and slides 30-second windows across it, so you do not need to chunk long files yourself. The result dictionary also carries the detected language and per-segment timings if you want more than the plain text — iterate result["segments"] to get start and end times for each chunk.

How do you turn a transcript into subtitles?

Whisper already writes an .srt file on every run, but understanding the format helps you trust it. SRT is just numbered blocks of timestamped text:

1
00:00:00,000 --> 00:00:04,120
Welcome back to the show. Today we are talking about offline AI.

2
00:00:04,120 --> 00:00:08,640
Our first topic is speech recognition on your own computer.

To get subtitles as your only output, pass --output_format srt (or vtt for web players like YouTube's caption importer). If you need word-level timing — karaoke-style highlighting — the reference CLI does not offer it; use faster-whisper with word_timestamps=True instead. And if you want a quick online alternative before committing to an install, our text-to-speech tool shows what in-browser speech tooling looks like (the reverse direction), though for real transcription work the offline model wins on privacy.

Should you use the Whisper API or run it locally?

Here is the 2026 news that changes the answer: whisper-1 is deprecated and shuts down on February 26, 2027. OpenAI now recommends gpt-transcribe for transcribing recorded speech in its original language, and the old /v1/audio/translations endpoint is deprecated too. If you are starting a new project on the API today, start with gpt-transcribe — do not build on whisper-1.

The honest local-vs-API math, verified against current docs:

Rule of thumb: transcribe locally when the audio is private, long, or frequent; use the API when you have no GPU and only an occasional short file. The API endpoint for file transcription is POST /v1/audio/transcriptions, and the 25 MB limit applies per request — a tip from the docs is to use a compressed format or split longer recordings into 25 MB chunks.

What are the beginner mistakes to avoid?

Sources

• OpenAI Whisper GitHub README (install, CLI usage, model table, Python API, turbo default, translate/turbo gotcha, ffmpeg commands, MIT license) — github.com/openai/whisper
• Whisper repository metadata via GitHub API (111,685 stars, 13,536 forks) — api.github.com/repos/openai/whisper
• PyPI openai-whisper (release 20250625, date-based versioning) — pypi.org/project/openai-whisper/
• faster-whisper GitHub README (26,364 stars, up to-4x speed claim, benchmark, install, code example, word timestamps, VAD, bundled decoder) — github.com/SYSTRAN/faster-whisper
• OpenAI speech-to-text docs (gpt-transcribe recommendation, whisper-1 deprecation, Feb 26 2027 shutdown, POST /v1/audio/transcriptions, 25 MB limit, supported formats) — developers.openai.com
• OpenAI models page (whisper-1 pricing $0.006/min, Deprecated status) — developers.openai.com/api/docs/models/whisper-1
• Offline SRT workflow verified against the official README — dev.to/jadenvo259/free-offline-srt-subtitles-with-openai-whisper-a-4-step-cli-workflow-l8j
• API tutorial corroborating endpoints and the 25 MB limit — gotranscript.com
• WhisperAI brand-disclaimer page (OpenAI does not own or endorse WhisperAI) — whisperai.com/blog/whisper-ai-guide

Frequently asked questions

Is Whisper free to use?

Yes. Whisper's code and model weights are released under the MIT license, so running it locally costs nothing beyond your own electricity — no account, no per-minute fee. The hosted API is the only paid lane, and even that is changing: whisper-1 is deprecated and shuts down on February 26, 2027.

How long does it take Whisper to transcribe an hour of audio?

It depends on the model and your hardware. The README's own measurements show turbo running about 8x faster than large on an A100 GPU, which puts an hour of English audio well under ten minutes there. On a CPU, expect roughly realtime to a few times slower with turbo, and much slower with large — which is exactly when faster-whisper's up-to-4x speedup earns its keep.

Can Whisper transcribe in real time?

Not by itself — the reference transcribe() reads the whole file and slides 30-second windows across it, so it is a batch tool. For live transcription, faster-whisper with streaming or the realtime API path (gpt-live-transcribe) is the honest answer, not the plain CLI.

What is the difference between Whisper and faster-whisper?

They are different installs of the same model weights. pip install -U openai-whisper gives you OpenAI's reference PyTorch package (CLI + simple API, needs system ffmpeg). pip install faster-whisper gives you SYSTRAN's CTranslate2 reimplementation — up to 4x faster for the same accuracy, less memory, no system ffmpeg needed, plus word-level timestamps and voice-activity detection.

Does Whisper work offline?

Completely, after the one-time model download. Once the weights are on your disk, the reference CLI and faster-whisper both transcribe with no internet connection — which is the whole point for private audio like interviews and meetings. The API lane, by contrast, uploads every file to OpenAI's servers.