How to transcribe audio with faster-whisper on a cloud GPU

Rent a GPU on Deploy, then open a terminal in JupyterLab or over SSH. Install faster-whisper from the official SYSTRAN/faster-whisper repository, load a size string the README prints, and transcribe. The README does not write an SRT file. A short writer on this page calls transcribe and writes SRT from segment.start, segment.end, and segment.text in that same loop. It was not run. Do not point it at the print loop’s segments variable: the README says that value is a generator, and the print loop already consumes it. Copy the transcript off the instance before you destroy it. Destroying the instance deletes its disk.

The repository LICENSE file is the MIT License, copyright 2023 SYSTRAN (read 2026-11-12). The README does not state a separate license for the weights that WhisperModel downloads. Read the model card on the Hub organization the README links before you redistribute those weights. PyPI listed version 1.2.1 on 2026-11-12, with Requires-Python >=3.9 and license MIT. The install command below is the README’s unpinned line, not a pin to 1.2.1.

The commands below are copied from the upstream README unless a step says this page added them. They were not run on a CloudGPU instance for this page.

What the README says about memory

The README’s large-v2 GPU table lists faster-whisper v1.1.0 (read 2026-11-12). The audio is the 13-minute file linked in that section. Beam size is 5. The README says the GPU benchmarks were executed with CUDA 12.4 on an NVIDIA RTX 3070 Ti 8GB. That card is not in the catalog below. The faster-whisper rows, copied:

Implementation line in the README Precision Time VRAM Usage
faster-whisper fp16 1m03s 4525MB
faster-whisper (batch_size=8) fp16 17s 6090MB
faster-whisper int8 59s 2926MB
faster-whisper (batch_size=8) int8 16s 4500MB

The opening paragraph says this implementation is up to 4 times faster than the Whisper repository it links, for the same accuracy, while using less memory. This page did not re-measure that sentence and does not name the linked repository. The same README has a second GPU table for a distil-whisper-large-v3 comparison. That table has no VRAM column. This page does not copy it.

GET /v1/public/compute-capabilities does not list GPUs. It returns feature flags. The memory column is vram_gb from gpu-prices.json, updated_at 2026-11-12T18:08:32.252Z. GET /v1/public/gpu-catalog the same day (generated_at 2026-11-12T18:08:33.832Z) listed the same names and the same vram_gb values, plus Ascend 910B, which is not in gpu-prices.json and is not listed here. The catalog response also includes an availability field. This page does not copy it. The README’s VRAM figures are megabytes from one card that is not in this catalog. This page does not convert those megabytes into vram_gb and does not mark a catalog row as enough. Which listing you can start is on Deploy. This page does not say which listings are available.

Catalog name vram_gb
RTX 2080 8
RTX 3080 10
RTX 2080 Ti 11
RTX 3080 Ti 12
V100 16G 16
A30 24
RTX 3090 24
RTX 4090 24
RTX 4090D 24
RTX 4080 SUPER 32G 32
RTX 5090 32
RTX 5090D 32
V100 32G 32
A100 40G 40
A800 40G 40
A40 48
RTX 4090 48G 48
RTX 4090D 48G 48
RTX A6000 48
NVIDIA RTX PRO 5000 72G 72
RTX PRO 5000 72G 72
A100 80G 80
A800 80G 80
H800 80
RTX 6000D 83
H20 96G 96
RTX PRO 6000 96G 96
RTX PRO 6000 Max-Q 96
H20-3e 141G 141

Speaker labels and a CLI that writes SRT are a different install: How to transcribe audio with WhisperX on a cloud GPU.

GPU libraries and install

On Deploy, choose Raw GPU. The README says Python 3.9 or greater. It says FFmpeg does not need to be installed on the system, because PyAV bundles the FFmpeg libraries.

The GPU section, copied in substance from the README: execution requires cuBLAS for CUDA 12 and cuDNN 9 for CUDA 12. The README says the latest versions of ctranslate2 only support CUDA 12 and cuDNN 9. For CUDA 11 and cuDNN 8, it says the workaround is ctranslate2==3.24.0. For CUDA 12 and cuDNN 8, it says downgrade to ctranslate2==4.4.0, and it prints pip install --force-reinstall ctranslate2==4.4.0. The Linux pip method and the library path, copied:

pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

export LD_LIBRARY_PATH=$(python3 -c 'import os, nvidia.cublas, nvidia.cudnn; print(os.path.dirname(nvidia.cublas.__path__[0]) + "/cublas/lib:" + os.path.dirname(nvidia.cudnn.__path__[0]) + "/cudnn/lib")')

The README says LD_LIBRARY_PATH must be set before launching Python. It also names the image nvidia/cuda:12.3.2-cudnn9-runtime-ubuntu22.04 as a Docker image that contains the libraries. This page did not run that image.

The PyPI install, copied:

pip install faster-whisper

The README says that loading a size such as WhisperModel("large-v3") downloads the CTranslate2 model from the Hugging Face Hub organization it links, https://huggingface.co/Systran. This page does not list the repository ids on that organization. cloudgpu-net is not in the README. The download speed guide says to leave it off during pip, then turn it on for a weight download. How to download a Hugging Face model is the manual download reference.

The README’s conversion section prints a ct2-transformers-converter line whose --model argument is a Hub id. Copy that line from the README if you convert a checkpoint yourself. This page does not paste it.

Transcribe

The README’s GPU example, copied. large-v3 is the size string in that block. The README says segments is a generator and that transcription starts when you iterate it.

from faster_whisper import WhisperModel

model_size = "large-v3"

# Run on GPU with FP16
model = WhisperModel(model_size, device="cuda", compute_type="float16")

segments, info = model.transcribe("audio.mp3", beam_size=5)

print("Detected language '%s' with probability %f" % (info.language, info.language_probability))

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

The same section comments two other constructors: compute_type="int8_float16" on CUDA, and device="cpu" with compute_type="int8". This page does not run either.

Batched transcription

The README says BatchedInferencePipeline.transcribe is a drop-in replacement for WhisperModel.transcribe. The snippet, copied. The size string in this block is turbo, and batch_size is 16. The README says the VAD filter is enabled by default for batched transcription.

from faster_whisper import WhisperModel, BatchedInferencePipeline

model = WhisperModel("turbo", device="cuda", compute_type="float16")
batched_model = BatchedInferencePipeline(model=model)
segments, info = batched_model.transcribe("audio.mp3", batch_size=16)

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

The README also prints model_size = "distil-large-v3" with language="en" and condition_on_previous_text=False, and it links the model card https://huggingface.co/distil-whisper/distil-large-v3. Word timings in the same README use word_timestamps=True and then segment.words.

Writing SRT

The README does not print an SRT writer. It says segments is a generator and that transcription starts when you iterate it. The print loop above is that iteration, so the name segments is empty afterwards. The block below is added by this page. It was not run. It calls transcribe itself and writes during that one iteration. It reads segment.start, segment.end, and segment.text. The HH:MM:SS,mmm formatting is this page’s, not the README’s. model is the WhisperModel from the example above.

def srt_time(seconds):
    ms = int(round(seconds * 1000))
    hours, ms = divmod(ms, 3_600_000)
    minutes, ms = divmod(ms, 60_000)
    secs, ms = divmod(ms, 1000)
    return f"{hours:02}:{minutes:02}:{secs:02},{ms:03}"

segments, _ = model.transcribe("audio.mp3", beam_size=5)
with open("audio.srt", "w", encoding="utf-8") as handle:
    for index, segment in enumerate(segments, start=1):
        handle.write(f"{index}\n{srt_time(segment.start)} --> {srt_time(segment.end)}\n{segment.text.strip()}\n\n")

WhisperX, and what this repository does not ship

The README lists WhisperX as a library that offers speaker diarization and word-level timestamps using wav2vec2 alignment. That CLI’s --output_format srt and --diarize flags are on the WhisperX guide. Use the faster-whisper calls above, including BatchedInferencePipeline, when you want the transcription the faster-whisper README documents. Use WhisperX when you want the speaker labels and the subtitle files that guide’s command writes. This page does not claim one library is faster than the other.

The faster-whisper README does not document ComfyUI. The ComfyUI examples top-level directory list on 2026-11-12 had no faster-whisper directory. The audio directory in that listing contained ace_step_example.flac and stable_audio_example.flac. This page does not add a ComfyUI workflow. The README does not ship a Gradio app. It names other projects, including a graphical program, in a community list. This page does not install those projects and has no upstream port to forward.

When it fails

CUDA or cuDNN mismatch. The README’s note is the version table above: latest ctranslate2 wants CUDA 12 and cuDNN 9, with the two pinned downgrades it prints for the older pairs. This page did not test those pins.

“CUDA error: no kernel image is available” on an RTX 5090. Catalog RTX 5090 and RTX 5090D are 32. That is the catalog value, not a faster-whisper requirement. The README’s GPU section is about cuBLAS and cuDNN, not a PyTorch arch list. The RTX 5090 guide says that card needs a PyTorch build for CUDA 12.8 or newer. This page did not test ctranslate2 on an RTX 5090.

CUDA out of memory. The README’s table is one measurement on an RTX 3070 Ti, not a cutoff for the catalog. The same table’s int8 row is 2926MB and its fp16 row is 4525MB, both for that one run. If the process raises an out-of-memory error, use how to fix CUDA out of memory on a cloud GPU.

Save the transcript, then destroy

Copy audio.srt, or the text you printed, before you destroy the instance. Save your work before you destroy a cloud GPU is the checklist. The terms say data on local instance storage is permanently deleted when the instance is destroyed. Billing is per minute, with a 1-minute minimum, and it stops when you destroy the instance. The billing rule is on the pricing page. Prices are not copied here.

Frequently asked questions

How much VRAM does the faster-whisper README publish?

The faster-whisper README’s large-v2 GPU table, for faster-whisper v1.1.0, reports VRAM Usage of 4525MB at fp16, 6090MB at fp16 with batch_size=8, 2926MB at int8, and 4500MB at int8 with batch_size=8 (read 2026-11-12). The README says those GPU benchmarks used CUDA 12.4 on an NVIDIA RTX 3070 Ti 8GB, beam size 5, and 13 minutes of audio. That card is not in the CloudGPU catalog read the same day. This page did not re-measure the table and does not mark any catalog vram_gb as enough or not enough. Which listing you can start is on https://cloudgpu.app/deploy.

What CUDA and cuDNN does the README require on a GPU?

The README says GPU execution requires cuBLAS for CUDA 12 and cuDNN 9 for CUDA 12. It says the latest versions of ctranslate2 only support CUDA 12 and cuDNN 9. It says the workaround for CUDA 11 and cuDNN 8 is ctranslate2==3.24.0, and for CUDA 12 and cuDNN 8 it is ctranslate2==4.4.0. It also prints a Linux pip install of nvidia-cublas-cu12 and nvidia-cudnn-cu12==9.* plus an LD_LIBRARY_PATH export. This page did not run those commands.

Does the official repository write an SRT file?

The faster-whisper README does not print a command that writes an SRT file. It prints segment.start, segment.end, and segment.text, and it says segments is a generator that transcription starts when you iterate. The writer added on this page calls transcribe and writes the SRT file in that same loop. It was not run. A second loop over the print example’s segments is empty. The README lists WhisperX for speaker diarization and word-level timestamps. The WhisperX guide documents --output_format srt.

When should I use WhisperX instead of faster-whisper?

Use the faster-whisper calls in its README, including BatchedInferencePipeline, when you want that library’s transcription. Use WhisperX when you want the speaker labels and the SRT or VTT files its CLI writes. The faster-whisper README says its own word_timestamps=True flag prints word timings, and it lists WhisperX for alignment and diarization. This page does not claim one is faster than the other.

Sources (read 2026-11-12, Asia/Shanghai)

Cards you can start are on the Deploy page. Prices are on https://cloudgpu.app/pricing and are not repeated here.

Last updated: 2026-11-12 (Asia/Shanghai).