Run Whisper on RTX 4060 (Transcription Setup)

VRAM Check: Whisper Models on 8 GB

The RTX 4060 with 8 GB VRAM is a cost-effective choice for running OpenAI Whisper transcription on a dedicated GPU server. Every Whisper model size fits on this card:

Even the largest Whisper model (large-v3) uses only 2.5 GB with Faster-Whisper at INT8, leaving over 5 GB free. This means you can co-host Whisper alongside a small LLM like Mistral 7B Q4 on the same GPU. See our Whisper vs Faster-Whisper speed comparison for backend details.

Setup with Faster-Whisper

Faster-Whisper delivers 5-6x speedups over stock Whisper with identical accuracy. It is the recommended backend for production use.

# Install Faster-Whisper
pip install faster-whisper

# Basic transcription
from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="int8")
segments, info = model.transcribe(
    "audio.mp3",
    beam_size=5,
    vad_filter=True,
    language="en"
)

print(f"Language: {info.language} (probability {info.language_probability:.2f})")
for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

Building a Transcription API

# Install FastAPI
pip install fastapi uvicorn python-multipart

# api.py
from fastapi import FastAPI, UploadFile
from faster_whisper import WhisperModel
import tempfile, os

app = FastAPI()
model = WhisperModel("large-v3", device="cuda", compute_type="int8")

@app.post("/transcribe")
async def transcribe(file: UploadFile):
    with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp:
        tmp.write(await file.read())
        tmp_path = tmp.name
    segments, info = model.transcribe(tmp_path, vad_filter=True)
    result = [{"start": s.start, "end": s.end, "text": s.text} for s in segments]
    os.unlink(tmp_path)
    return {"language": info.language, "segments": result}

# Run: uvicorn api:app --host 0.0.0.0 --port 8000

This gives you an OpenAI Whisper API-compatible endpoint running on your own hardware. Read our self-host guide for server setup fundamentals.

RTX 4060 Transcription Benchmarks

Tested with a 60-minute English podcast (mono, 16kHz). See the benchmark tool for more data.

Faster-Whisper large-v3 on the RTX 4060 transcribes audio at 46x real-time speed, meaning it processes a 60-minute file in under 80 seconds. Even the medium model at 88x real-time is production-quality for most use cases. Visit the benchmarks hub for cross-GPU comparisons.

Optimisation Tips

• Enable VAD filtering (vad_filter=True) to skip silent sections. This can reduce processing time by 20-40% on typical audio with pauses.
• Use INT8 compute for the best speed-to-accuracy ratio on Ada Lovelace GPUs.
• Batch multiple files with threading to keep the GPU saturated during I/O-bound operations.
• Use the medium model when 3.4% WER is acceptable. It is 2x faster than large-v3 with only 0.7% more errors.
• Pre-convert audio to 16kHz mono WAV to eliminate format-conversion overhead during transcription.

Use our cost calculator to estimate per-hour transcription costs.

Next Steps

The RTX 4060 is an ideal budget card for Whisper transcription. For higher throughput or multi-stream processing, upgrade to an RTX 3090. Pair Whisper with an LLM for automatic summarisation, both fit on the same card. Browse all deployment guides in the model guides section, or check the RTX 4060 Ti for a mid-range upgrade.