How to Install OpenAI Whisper (2026 Setup Guide)

Which install path is right for you?

Four Whisper implementations plus Docker. Pick before you install — switching later means environment cleanup.

Prerequisites

Whisper needs three decisions before pip install will get you a working install: a supported Python version, the FFmpeg binary, and whether you want GPU acceleration.

Python version compatibility

The openai/whisper README states 3.8-3.11, but the actual pyproject.toml classifiers list 3.8 through 3.13. In practice, 3.12 works cleanly since v20250625; 3.13 has known build failures on tiktoken and triton dependencies. Verified 2026-08-15.

Why FFmpeg is required

Whisper reads audio through FFmpeg — it shells out to the ffmpeg binary to decode MP3, M4A, WAV, MP4, and other formats into raw waveforms before feeding them to the model. FFmpeg is not a pip package; you install it through your operating system's package manager. Per-OS commands are in each install section below.

GPU vs CPU — do you need CUDA?

Decision rules based on model size + weekly audio volume:

• Tiny or base model, under 2 hours/week — CPU is fine. Skip CUDA setup.
• Small or medium model, under 5 hours/week — CPU works but slow (0.5-2× real-time). Consider GPU if latency matters.
• Large or turbo model, any regular use — GPU strongly recommended. CPU-only large is roughly 0.05× real-time (a 10-min podcast takes ~3 hours).
• Apple Silicon Mac — Metal (MPS backend) works via PyTorch 2.0+, no CUDA needed. faster-whisper does not currently support MPS.
• Windows or Linux with NVIDIA GPU — install CUDA-enabled PyTorch (see per-OS sections).
• macOS with AMD or Intel iGPU — no CUDA. whisper.cpp with Metal is the fastest path.

Install Whisper on Windows

Windows install: install Python, install FFmpeg, install openai-whisper. The most common Windows-specific gotcha is FFmpeg not being on PATH after install — reopen your terminal after installing FFmpeg so the new PATH is picked up.

1. Install Python

Download Python 3.11 (recommended) from python.org and check "Add Python to PATH" during install.

2. Install FFmpeg on Windows

Pick one of three methods:

choco install ffmpeg

winget install Gyan.FFmpeg

3. Install openai-whisper

python -m pip install -U openai-whisper

Using python -m pip instead of bare pip guarantees the install goes into the Python you'll actually run.

4. Enable NVIDIA GPU (optional but recommended for large model)

Check your CUDA version:

nvidia-smi

Install CUDA-enabled PyTorch matching your CUDA version. For CUDA 12.1:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

For other CUDA versions see pytorch.org/get-started/locally. Verify:

python -c "import torch; print(torch.cuda.is_available())"

5. Verify installation

whisper --help

If "whisper is not recognized", Python's Scripts directory isn't on PATH — reopen your terminal or add%APPDATA%\Python\Python311\Scriptsto PATH.

Install Whisper on macOS

macOS install is the smoothest of the three main platforms — Homebrew handles both Python and FFmpeg cleanly. Apple Silicon Macs get PyTorch's MPS backend for Metal-accelerated inference without needing CUDA.

1. Install Homebrew (if you don't have it)

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Install Python and FFmpeg

brew install python@3.11 ffmpeg

3. Install openai-whisper

python3.11 -m pip install -U openai-whisper

Apple Silicon note (M1/M2/M3/M4)

openai-whisper runs on CPU by default. To use the Metal GPU, ensure PyTorch is 2.0+ — pip pulls the correct build automatically on Apple Silicon. faster-whisper does not currently support MPS; on Apple Silicon consider whisper.cpp for GPU acceleration via Metal.

Why CUDA is not available on macOS

Apple dropped NVIDIA GPU support in macOS Mojave (2018). No CUDA drivers exist for modern macOS. Your options are: CPU inference (fine for small models), MPS via PyTorch 2.0+ (Apple Silicon), or whisper.cpp with Metal. For maximum throughput on Mac, whisper.cpp with Core ML acceleration beats openai-whisper on Apple Silicon.

4. Verify installation

whisper --help

Install Whisper on Linux (Ubuntu / Debian)

Linux is the reference environment — Whisper's CI runs on Ubuntu, so this path sees the fewest edge cases.

1. Install Python and FFmpeg

sudo apt update
sudo apt install -y python3 python3-pip ffmpeg

Arch: sudo pacman -S python python-pip ffmpeg. Fedora/RHEL: sudo dnf install python3 python3-pip ffmpeg (FFmpeg requires the RPM Fusion repository on Fedora).

2. Install openai-whisper

python3 -m pip install -U openai-whisper

3. NVIDIA GPU setup with CUDA + cuBLAS + cuDNN

Critical for faster-whisper users: ctranslate2 4.5.0+ requires CUDA 12.3+ with cuDNN 9. Check your CUDA version:

nvidia-smi

Install PyTorch matching your CUDA version. For CUDA 12.1:

pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121

For faster-whisper without system CUDA installation, install NVIDIA libraries via pip and set LD_LIBRARY_PATH:

pip install nvidia-cublas-cu12 nvidia-cudnn-cu12
export LD_LIBRARY_PATH=$(python -c "import site; import os; print(os.path.join(site.getsitepackages()[0], 'nvidia', 'cublas', 'lib') + ':' + os.path.join(site.getsitepackages()[0], 'nvidia', 'cudnn', 'lib'))")

4. Verify installation

whisper --help
python -c "import torch; print(torch.cuda.is_available())"

Install Whisper on Google Colab

Colab is the fastest path to running Whisper large-v3 on a GPU without owning one. Free tier: T4 GPU (16 GB VRAM), fits every Whisper model including large. Colab Pro: A100 or L4 for higher throughput.

!pip install -U openai-whisper
!apt-get install -y ffmpeg

from google.colab import files
uploaded = files.upload()  # pick your audio file

import whisper
model = whisper.load_model("large-v3")
result = model.transcribe(list(uploaded.keys())[0])
print(result["text"])

Enable the GPU runtime first: Runtime → Change runtime type → T4 GPU (free) or A100/L4 (Pro). Free tier sessions disconnect after ~90 minutes idle and cap at ~12 hours total per day. For sustained use, Colab Pro ($10/mo) or a hosted transcription service avoids the reconnect friction.

Install via Docker (production deployment)

Docker is the cleanest production install path: no host env pollution, repeatable across machines, GPU passthrough handled. Two paths depending on whether you want an API server or CLI.

Option A — official CUDA base + faster-whisper install

Use NVIDIA's CUDA 12.3 + cuDNN 9 image as the base, install faster-whisper inside:

docker run --gpus all -it \
  -v $(pwd):/workspace \
  nvidia/cuda:12.3.2-cudnn9-runtime-ubuntu22.04 \
  bash

# inside the container:
apt update && apt install -y python3 python3-pip ffmpeg
pip install faster-whisper
python -c "from faster_whisper import WhisperModel; m = WhisperModel('base'); print(next(m.transcribe('/workspace/audio.mp3')[0]))"

Option B — pre-built faster-whisper image

Ready-to-run community image:

docker pull lewangdev/faster-whisper
docker run --gpus all -v $(pwd):/workspace lewangdev/faster-whisper \
  --model base --language en /workspace/audio.mp3

Option C — full transcription API server

For a REST API endpoint (POST audio, get JSON transcript):

docker pull onerahmet/openai-whisper-asr-webservice
docker run -d --gpus all -p 9000:9000 \
  -e ASR_MODEL=base \
  -e ASR_ENGINE=faster_whisper \
  onerahmet/openai-whisper-asr-webservice

Then POST audio to http://localhost:9000/asr. Full API docs at github.com/ahmetoner/whisper-asr-webservice.

openai-whisper vs faster-whisper vs whisperX vs whisper.cpp

"Which Whisper implementation should I use?" is the most common question in every Whisper Reddit thread. Four implementations dominate, each optimized for a different constraint. All use the same underlying model weights — the difference is the inference runtime.

faster-whisper reports up to 4× throughput vs openai-whisper on the same GPU with the same model weights, using CTranslate2 as the inference engine. Per project benchmark: large-v2 on GPU dropped from 4,708 MB VRAM (openai-whisper fp16) to 2,926 MB (faster-whisper int8). Verified 2026-08-15 against github.com/SYSTRAN/faster-whisper.

Choosing a model size

Whisper ships six model sizes plus English-only variants for the smaller four. Model size trades accuracy for speed and VRAM. Table copied verbatim from the openai/whisper README (verified 2026-08-15).

Which model should you pick?

• Have a GPU with 10+ GB VRAM? Use large for max accuracy or turbo for near-large accuracy at 8× the speed.
• Have a mid-range GPU (5-8 GB VRAM)? medium is the accuracy sweet spot; turbo fits if the GPU has 6+ GB.
• CPU-only or 2 GB VRAM? small balances quality and runtime. base.en is faster if you only need English.
• Draft-quality only, low-power device? tiny or tiny.en.

For detailed word error rate benchmarks per model size and language see how accurate is Whisper.

First-run performance — what to expect

Before you download 3 GB of weights, know what runtime to expect. The table below shows approximate real-time factor (RTF) for openai-whisper on common hardware. Higher = faster. RTF of 5× means a 10-minute clip transcribes in 2 minutes. Numbers are community-reported 2026 estimates and vary with audio complexity, batch size, and driver version. faster-whisper is roughly 2-4× faster than these numbers on the same hardware.

Model download happens once on first use — ~150 MB (base) to ~3 GB (large), cached in ~/.cache/whisper/. Subsequent runs load from cache. First-run wall-clock time includes the download; second-run and later use only the RTF above.

Your first transcription

Command line (CLI)

The simplest path — one command, no code:

whisper audio.mp3 --model base --output_format txt

Whisper detects the language automatically, transcribes the file, and writes audio.txt to the current directory. Add --language en to skip auto-detection. Available output formats: txt, vtt, srt, tsv, json, all.

Python API

import whisper

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

faster-whisper Python API (recommended for production)

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cuda", compute_type="int8_float16")
segments, info = model.transcribe("audio.mp3", beam_size=5)
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

whisperX (with speaker labels)

import whisperx
import os

model = whisperx.load_model("base", device="cuda")
audio = whisperx.load_audio("audio.mp3")
result = model.transcribe(audio)

# Align for word-level timestamps
model_a, metadata = whisperx.load_align_model(language_code=result["language"], device="cuda")
result = whisperx.align(result["segments"], model_a, metadata, audio, "cuda")

# Diarize (requires HF_TOKEN with pyannote model access)
diarize_model = whisperx.DiarizationPipeline(use_auth_token=os.environ["HF_TOKEN"], device="cuda")
diarize_segments = diarize_model(audio)
result = whisperx.assign_word_speakers(diarize_segments, result)

Common install errors and fixes

The seven errors that dominate the openai/whisper GitHub Discussions install threads. Skim for your error message.

Licensing, privacy, and data handling

MIT license — commercial use is fine

Whisper's code and model weights are released under the MIT license. Self-host, modify, fine-tune, and include Whisper in commercial products without paying OpenAI or requesting permission. The license text is at github.com/openai/whisper/blob/main/LICENSE.

Runs locally — no data sent to OpenAI

Self-hosted Whisper (this install guide) runs entirely on your machine. No audio, transcripts, or metadata leaves your local environment. No API key required. No account required. Distinct from the OpenAI Whisper API, which is a paid hosted service where audio is uploaded to OpenAI.

Self-hosted Whisper vs OpenAI Whisper API

Two things share the "Whisper" name. Self-hosted Whisper is what you installed above — free, local, MIT-licensed. The OpenAI Whisper API is a paid hosted service ($0.006 per minute as of 2026-08-15) that removes the install burden but sends audio to OpenAI. Pick the API for zero setup + fine sending audio out; pick self-hosted for privacy, unlimited volume, or offline operation.

When to use hosted Whisper instead

Installing and maintaining Whisper is worth it for a real set of use cases: strict data-locality requirements, high monthly volume where per-minute API fees add up, embedded systems that need offline transcription, or research workflows where you need to modify the model.

For everything else — occasional transcription, no GPU handy, don't want to maintain a Python environment or CUDA driver — a hosted transcription service is usually the right call. VexaScribe runs Whisper large-v3 on the hosting side, adds speaker diarization (up to 50 speakers), and handles format conversion, model download, and GPU provisioning. Free tier available; no install required.

Verified sources

Every command, version number, and library reference on this page was cross-checked against these sources on 2026-08-15:

• github.com/openai/whisper — README, LICENSE, Discussions #47 (CUDA GPU thread)
• pypi.org/project/openai-whisper — Python classifiers, current version
• github.com/SYSTRAN/faster-whisper — 4× speed claim, CUDA 12.3+ requirement, Issue #783/#998
• github.com/ggml-org/whisper.cpp — CPU-first implementation
• github.com/m-bain/whisperX — v3.8.6 diarization backend switch
• pytorch.org/get-started/locally — CUDA-matched PyTorch install URLs
• hub.docker.com/r/lewangdev/faster-whisper — pre-built Docker image
• github.com/ahmetoner/whisper-asr-webservice — REST API server image

Frequently asked questions

Related guides