How to Convert Audio to Text Locally for Free Using Whisper.cpp in 2026

You do not need a cloud account to turn speech into text. In 2026 the open Whisper family runs well on ordinary laptops: whisper.cpp for a lean C/C++ CLI, and faster-whisper for Python pipelines. Both keep audio on your machine after the model is downloaded.

This guide walks through both paths with working commands and code, then compares living in the terminal to WisprKit, a cross-platform desktop app built around local engines. Free tier available, no subscription required for core local use.

1. Why convert audio to text locally

Cloud transcription is convenient until the file is a private interview, a client call, or an unpublished podcast stem. Local Whisper-style models invert that tradeoff: you pay with disk space and CPU or GPU time, and you keep control of retention.

• Privacy. No vendor account holding your raw audio by default.
• Cost. No per-minute fees after you own the hardware.
• Offline. Useful on planes, locked-down networks, or air-gapped machines once models are cached.

2. whisper.cpp on the command line (C/C++)

whisper.cpp is a C/C++ port of Whisper with ggml models. It is a strong default on Apple Silicon (Metal) and on CPU-only machines where you want a small dependency footprint and no Python runtime.

Install dependencies

macOS (Homebrew):

$ xcode-select --install
$ brew install cmake ffmpeg

Ubuntu or Debian:

$ sudo apt update
$ sudo apt install build-essential cmake ffmpeg

Clone, download a model, and build

$ git clone https://github.com/ggml-org/whisper.cpp.git
$ cd whisper.cpp
$ sh ./models/download-ggml-model.sh base.en
$ cmake -B build
$ cmake --build build -j --config Release

Swap base.en for small, medium, large-v3, or large-v3-turbo depending on accuracy and hardware. English-only models use the .en suffix; multilingual models omit it.

Transcribe a file

# WAV works best; convert with ffmpeg if needed
$ ffmpeg -i interview.mp3 -ar 16000 -ac 1 interview.wav

$ ./build/bin/whisper-cli     -m models/ggml-base.en.bin     -f interview.wav     -l en     -otxt -osrt     -of interview

This writes text and SRT next to your chosen output prefix. On Apple Silicon, Metal is typically enabled in Release builds; see the project README for Core ML flags if you want encoder acceleration.

Minimal C++-style usage note

The maintained entry point for most users is the official CLI binary above. If you embed whisper.cpp in your own C++ project, you link the library, load a ggml model path, and call the C API to run inference on PCM samples. A sketch of the control flow:

1// Pseudocode outline for embedding whisper.cpp (see upstream examples)
2#include "whisper.h"
3 
4struct whisper_context * ctx =
5    whisper_init_from_file_with_params("models/ggml-base.en.bin", params);
6 
7// Fill float PCM at 16 kHz mono, then:
8whisper_full(ctx, wparams, pcmf32.data(), pcmf32.size());
9 
10const int n = whisper_full_n_segments(ctx);
11for (int i = 0; i < n; ++i) {
12    const char * text = whisper_full_get_segment_text(ctx, i);
13    // write text / timestamps
14}
15 
16whisper_free(ctx);

Prefer the upstream examples/ tree in the whisper.cpp repository for production-ready C/C++ samples rather than copying pseudocode into shipping software.

3. Python with faster-whisper

faster-whisper is a Python reimplementation on CTranslate2. On NVIDIA GPUs it is often the throughput winner. On CPU it remains practical with int8 compute.

Setup

$ python3 -m venv ~/whisper-env
$ source ~/whisper-env/bin/activate
# Windows: whisper-envScriptsactivate
$ pip install -U pip
$ pip install faster-whisper

Transcribe script

1from faster_whisper import WhisperModel
2 
3# GPU:
4# model = WhisperModel("large-v3-turbo", device="cuda", compute_type="float16")
5 
6# CPU:
7model = WhisperModel("small", device="cpu", compute_type="int8")
8 
9segments, info = model.transcribe(
10    "interview.wav",
11    language="en",
12    beam_size=5,
13    vad_filter=True,
14)
15 
16print("Detected language:", info.language, "probability:", info.language_probability)
17 
18with open("interview.txt", "w", encoding="utf-8") as out:
19    for segment in segments:
20        line = f"[{segment.start:.2f} -> {segment.end:.2f}] {segment.text.strip()}"
21        print(line)
22        out.write(segment.text.strip() + "
23")

First run downloads the model weights into a local cache. After that, you can transcribe offline. For SRT, map each segment start and end into standard subtitle timestamps in a few extra lines of Python.

4. Manual scripts versus a local desktop app

Scripts are the right tool when you need automation, servers, or custom pipelines. A desktop app is the right tool when you want drag-and-drop, a library of past jobs, and exports without maintaining a toolchain.

5. WisprKit overview

Free tier · Optional one-time Pro

WisprKit is a cross-platform desktop app for local media conversion and Whisper-based transcription. It targets Windows, macOS, and Linux, with acceleration paths such as CUDA and Metal where hardware allows. Processing is designed to stay on your machine. There is no subscription for the core product model: free capabilities for everyday local work, and a one-time Pro unlock for advanced features.

Under the hood it builds on the same ideas as the scripts above: local Whisper-family models, FFmpeg-powered conversion, and optional local translation. The difference is packaging: a library UI, guided flows, and production exports without maintaining a personal CLI toolkit.

Try out WisprKit

6. Feature: Transcribe

Drop almost any common audio or video file, or record from the microphone. WisprKit runs local Whisper-class models so the speech-to-text step does not depend on a cloud STT API. You choose model size based on speed versus accuracy, then export a clean transcript or subtitles.

This is the direct alternative to calling whisper-cli or a Python transcribe() loop when you want the same local property with less setup.

7. Feature: Speaker separation

Speaker diarization labels who spoke when. On Pro, WisprKit supports separation for up to four speakers, with rename and edit of turns, then export of speaker-aware subtitles. That matters for podcast interviews and meetings where a flat transcript is harder to edit.

Doing the same with pure scripts usually means an extra diarization model or pipeline wired to your Whisper output. The app keeps that path inside one workspace.

8. Feature: Translate

Pro translation runs inside the app using local neural translation (NLLB-class), aimed at wide language coverage. You can edit results and export without sending the original audio to a third-party translation API for that step.

Script users often chain Whisper output into a separate translation model or service. WisprKit collapses that into one local studio for teams that localize show notes or subtitles.

9. Feature: Convert media

Before transcription you often need a consistent format, sample rate, or crop. WisprKit includes local conversion for common video and audio containers, with practical controls such as aspect presets and basic cleanup. That replaces a pile of one-off ffmpeg commands for many creator workflows while still keeping processing on-device.

10. Feature: Batch workflows

Batch processing is where scripts shine, and where a desktop app has to earn its place. WisprKit focuses on folder and multi-file queues so producers can run overnight jobs without writing for f in *.wav loops. Advanced batch and queue features sit on Pro; the idea is the same as a well-written CLI pipeline, packaged for non-terminal users.

11. Feature: Production exports

Transcripts only help if they land in your editor or CMS. WisprKit exports common subtitle and text formats (SRT, VTT, TXT, JSON, CSV, Markdown, and additional document formats on higher tiers) so you can move from local STT to publishing without a manual cleanup marathon.

Try out WisprKit