12 November 2026 · VRAMfarm team

Whisper transcription on a GPU: large-v3 or turbo, faster-whisper and WhisperX speakers

A hundred hours of recorded interviews sounds like weeks of typing. On a rented RTX 4090, Whisper large-v3 transcribes it in about one to two hours of GPU time, roughly €0.89, with timestamps for every sentence. The model needs only 3–10 GB of memory, so the question is less “which card fits” and more which version of Whisper to run and how to keep the GPU busy.

Which Whisper: large-v3, turbo or smaller

OpenAI’s Whisper comes in several sizes. Two matter for GPU work, and they share the same encoder design but differ in the decoder.

Turbo is large-v3 with a much smaller decoder (4 layers instead of 32). On clear speech its accuracy is close to large-v3 and it runs several times faster. It makes more mistakes with accents, crosstalk and rare languages, and it was not trained for translation. A good default: turbo for clean recordings like podcasts and lectures, large-v3 for phone calls, noisy rooms, strong accents or anything you will quote.

faster-whisper is a reimplementation of Whisper on the CTranslate2 engine. Same models and practically the same accuracy, up to about four times faster than OpenAI’s code with less memory, and it can quantise to int8 with little loss. WhisperX builds on faster-whisper and adds two things: word-level timestamps through a separate alignment model, and speaker labels (diarisation).

Do you need a GPU at all?

For a few recordings a month, no. A laptop with Apple Silicon or a recent CPU runs turbo through whisper.cpp at a comfortable pace, and hosted transcription APIs charge per minute with no setup. Hosted Whisper-class APIs cost from a few cents to about €0.30 per audio hour (November 2026), depending on the provider and model.

A rented GPU wins when:

• you have volume: tens or hundreds of hours, where the per-hour API price adds up and the GPU is busy every minute;
• the recordings are sensitive: interviews, patients, internal calls that you don’t want to send to a third-party API;
• you need speaker labels or a custom pipeline, such as transcribe, label speakers, then summarise with a local LLM;
• files are large: many APIs cap the size of a single upload; your own server doesn’t care.

Speed: hours of audio per GPU-hour

Whisper speed is usually given as a multiple of real time: 50× means an hour of audio in 72 seconds. The biggest lever is not the card but batching: faster-whisper’s batched pipeline sends many 30-second chunks through the model at once, which keeps a modern GPU busy.

Read each number as “hours of audio per GPU-hour”. These are planning ranges from public benchmarks and the cards’ specs, not our measurements. Real speed depends on how much of the audio is speech, beam size, VAD settings and the CPU, which decodes the audio files and can become the bottleneck at the top end. Diarisation in WhisperX adds a separate pass; plan on 30–60% more time for long files.

The cheapest card per audio hour is usually the RTX 3090 or the RTX 4090, whichever has the better price ratio at the time; the pricing page shows both. Datacenter cards like the H100 are faster still, but transcription doesn’t use their memory and they cost several times more per hour.

Setting up faster-whisper on a rented server

There is no ready-made Whisper app; an empty PyTorch + Jupyter server is all you need. Choose a 12–24 GB card, launch, and open Jupyter → File → New → Terminal (or SSH, see the SSH key guide).

Upload the audio first. Converting it on your computer to 16 kHz mono saves a lot of upload time without hurting accuracy, because Whisper resamples to 16 kHz anyway: an hour of 128 kbps MP3 is about 58 MB, an hour of 16 kHz mono Opus about 11 MB.

# on your computer, once per file
ffmpeg -i interview.mp4 -vn -ac 1 -ar 16000 -c:a libopus -b:a 24k interview.opus

Upload a zip through Jupyter or with scp, or download it on the server from your own cloud storage. Then on the server:

pip install faster-whisper
mkdir -p /workspace/audio /workspace/out   # put the audio files into /workspace/audio

Save this as /workspace/transcribe.py:

import glob, os
from faster_whisper import WhisperModel, BatchedInferencePipeline

model = WhisperModel("large-v3", device="cuda", compute_type="float16")  # or "large-v3-turbo"
batched = BatchedInferencePipeline(model=model)

def ts(t):
    h, rem = divmod(t, 3600); m, s = divmod(rem, 60)
    return f"{int(h):02}:{int(m):02}:{s:06.3f}".replace(".", ",")

for path in sorted(glob.glob("/workspace/audio/*")):
    name = os.path.splitext(os.path.basename(path))[0]
    segments, info = batched.transcribe(path, batch_size=16, vad_filter=True)  # add language="de" if you know it
    with open(f"/workspace/out/{name}.srt", "w") as srt, open(f"/workspace/out/{name}.txt", "w") as txt:
        for i, seg in enumerate(segments, 1):
            srt.write(f"{i}\n{ts(seg.start)} --> {ts(seg.end)}\n{seg.text.strip()}\n\n")
            txt.write(seg.text.strip() + "\n")
    print(name, info.language, round(info.duration / 60), "min")

Run it with nohup python /workspace/transcribe.py > /workspace/log.txt 2>&1 & so it keeps going when you close the browser. The first run downloads the model (about 3 GB for large-v3), which counts as traffic at the machine’s rate.

If faster-whisper complains that it can’t load libcudnn or libcublas, the CUDA libraries it expects are missing from the path: pip install nvidia-cublas-cu12 nvidia-cudnn-cu12 and follow the LD_LIBRARY_PATH line in the faster-whisper README. The machine’s driver and CUDA version are shown before launch; more on that in CUDA and driver mismatches.

Setting language when you know it saves time and avoids the occasional wrong guess on a quiet first 30 seconds. With batch_size=16, large-v3 uses roughly 6–10 GB of VRAM; on a 12 GB card, drop to 8 if you run out of memory.

Speaker labels with WhisperX

For interviews and meetings you usually want “Speaker 1 / Speaker 2”, not one block of text. WhisperX does it in one command. It pins its own versions of PyTorch and other libraries, so install it in a separate virtual environment to keep it from breaking other tools (it downloads its own PyTorch, a few more GB of traffic):

apt-get update && apt-get install -y ffmpeg
python -m venv /workspace/wx && . /workspace/wx/bin/activate
pip install whisperx
export HF_TOKEN=<your Hugging Face read token>
whisperx /workspace/audio/meeting.opus --model large-v3 --language en \
  --diarize --hf_token $HF_TOKEN --output_format srt --output_dir /workspace/out

The diarisation models come from pyannote and are gated on Hugging Face: open their model pages, accept the terms, and use a read token. Add --min_speakers 2 --max_speakers 4 when you know the count; it noticeably improves the split. Expect a few more gigabytes of VRAM on top of transcription; a 24 GB card has plenty of room.

Diarisation is the weakest link in the chain. Overlapping speech, similar voices and short interjections (“yes”, “right”) get the wrong label more often than Whisper gets the words wrong. Check the speakers in the first minutes before trusting a long transcript.

Subtitles: SRT and VTT

The script above writes SRT files with one Whisper segment per subtitle. Segments can be long, up to 30 seconds of speech, which reads badly on screen. WhisperX handles this better, because it aligns every word to the audio:

whisperx video.opus --model large-v3 --language en --output_format srt \
  --max_line_width 42 --max_line_count 2 --output_dir /workspace/out

That gives subtitles of at most two lines of 42 characters, a common broadcast style, with timing that follows the words. Use --output_format vtt for web players. YouTube, Premiere, DaVinci Resolve and most players import SRT directly. For translated subtitles, either use Whisper’s translate mode into English, or transcribe in the original language and translate the SRT text with a local LLM, which usually reads more naturally.

What 100 hours of audio costs

At the middle of the ranges above, with batched faster-whisper:

Add 10–15 minutes for setup and model downloads. Small jobs pay the minimum of 15 minutes per launch: one hour of audio costs at least €0.15 on an RTX 4090, however fast it runs. So collect recordings and transcribe them in one session rather than one file per launch.

Against an API at about €0.15–0.30 per audio hour (November 2026), the same 100 hours would cost about €15–30, and the cheapest fast-inference providers a few euros. The GPU is cheaper at volume, but it is your setup and your time; for five hours of audio a month, the API is the sensible choice.

When the script finishes, zip /workspace/out, download it from Jupyter and stop the server. If you will run the same job again next week, Save and stop keeps the scripts and the WhisperX environment in /workspace (the environment alone is a few GB of storage); delete the audio first if it shouldn’t be stored. The Whisper page has the short version of these commands.