Local Speech to Text for Team Meetings on Ubuntu (Whisper)

The most reliable way to transcribe team meetings locally on Ubuntu is to record the call to a WAV file and run a Whisper engine on your own machine afterwards. faster-whisper is the easiest from Python, and whisper.cpp suits CPU-only laptops. If you’d rather not touch a terminal, Speech Note and Buzz give you the same engines behind a window. Nothing gets uploaded, and after the one-time model download you don’t need an internet connection at all.

This guide covers capturing Zoom, Teams, Meet or Jitsi audio on Ubuntu, turning it into text, adding speaker labels, and when a phone on the table beats all of it.

Which local transcription tool should you use on Ubuntu? #

All four options below run the same family of OpenAI Whisper models. They differ in how much setup they need.

Speech Note processes speech, translation and text-to-speech entirely offline. Buzz is MIT-licensed, exports TXT, SRT and VTT, and includes speaker identification. faster-whisper reimplements Whisper on the CTranslate2 engine and claims up to four times the speed of OpenAI’s reference code at the same accuracy, with less memory.

Step 1: Record the meeting audio #

Ubuntu has used PipeWire for audio since 22.10, and it still accepts the familiar pactl commands. Every output device has a “monitor” source you can record. The trap is that the monitor only holds what comes out of your speakers, meaning everyone except you. Record your microphone as well and mix the two.

1. List your audio sources:

   pactl list short sources

   Your mic is usually an alsa_input... entry. The call audio is the matching alsa_output....monitor entry.

2. Record both into one 16 kHz mono file, which is the format Whisper wants:

   ffmpeg -f pulse -i <mic-source> -f pulse -i <output-monitor> \
     -filter_complex amix=inputs=2 -ac 1 -ar 16000 meeting.wav

3. Press q in the terminal when the meeting ends.

This works the same for Zoom, Teams in the browser, Google Meet and self-hosted Jitsi, because you’re recording the system audio rather than hooking into the meeting app. For the Meet-specific version, including Mac and Windows capture, see Google Meet transcription without bots.

Step 2: Transcribe with faster-whisper #

Create a virtual environment so nothing touches the system Python:

sudo apt install -y python3-venv ffmpeg
python3 -m venv ~/whisper-env
source ~/whisper-env/bin/activate
pip install faster-whisper

Save this as transcribe.py:

import sys
from faster_whisper import WhisperModel

# CPU: "small" or "medium" with int8. NVIDIA GPU: "large-v3", device="cuda", compute_type="float16"
model = WhisperModel("medium", device="cpu", compute_type="int8")
segments, info = model.transcribe(sys.argv[1], beam_size=5, vad_filter=True)

with open(sys.argv[1] + ".txt", "w") as out:
    for s in segments:
        out.write(f"[{s.start:7.1f}s] {s.text.strip()}\n")

Run it with python transcribe.py meeting.wav, and you get meeting.wav.txt with a timestamp on every line. The vad_filter option skips long silences, which speeds things up and stops Whisper from inventing text during dead air.

If you have an NVIDIA card, faster-whisper’s current releases need CUDA 12 and cuDNN 9. Its own benchmark transcribes 13 minutes of audio in about a minute on a GPU with int8. On a CPU, “medium” can take roughly as long as the meeting itself, depending on your processor. Drop to “small” or “base.en” if you need the text sooner.

The whisper.cpp alternative #

whisper.cpp is a single compiled binary with no Python dependencies, and it’s efficient on CPUs:

git clone https://github.com/ggml-org/whisper.cpp
cd whisper.cpp
cmake -B build && cmake --build build -j --config Release
sh ./models/download-ggml-model.sh base.en
./build/bin/whisper-cli -m models/ggml-base.en.bin -f meeting.wav -otxt -osrt

The .en models are English-only and faster. Use the multilingual ones (drop the .en) if your team speaks another language or switches between languages.

Step 3: Add speaker labels #

Whisper produces words and timestamps, not names. For “who said what,” pyannote.audio runs speaker diarization locally. Its free speaker-diarization-community-1 pipeline runs on your machine, but you’ll need a Hugging Face access token and to accept the model’s conditions once so you can download it.

from pyannote.audio import Pipeline

pipeline = Pipeline.from_pretrained(
    "pyannote/speaker-diarization-community-1", token="YOUR_HF_TOKEN")
output = pipeline("meeting.wav")
for turn, speaker in output.speaker_diarization:
    print(f"{turn.start:.1f}-{turn.end:.1f}s  speaker_{speaker}")

Match each Whisper segment to the speaker whose turn overlaps it most, then replace speaker_0 with real names by hand. Expect clean results for two or three people who take turns and messy ones for a lively standup where everyone talks at once. If you want this without writing code, Buzz has speaker identification built in.

Can you get live captions during the call? #

Yes, with limits. whisper.cpp includes whisper-stream, which transcribes a microphone or monitor source every half second:

./build/bin/whisper-stream -m ./models/ggml-base.en.bin -t 8 --step 500 --length 5000

Live text runs a few seconds behind and is less accurate than a full pass over the finished recording, because the model sees less context. A practical pattern is live captions for following along, then the recorded file through a bigger model for the notes you actually keep.

When the meeting is in a room, use a phone #

If your team meets in person, you don’t need a laptop capture chain at all. A phone in the middle of the table often picks up voices better than a laptop’s fan-adjacent mic.

Private Transcribe is our offline transcription app for iPhone and Android. It runs Whisper on the phone’s processor, so the recording and transcript never leave the device and there’s no account to create. It keeps recording with the screen locked, puts timestamps on every line, and has a custom vocabulary list for project names and colleagues’ names. It can also import a meeting recording (m4a, mp3, wav, mp4 and more, up to 90 minutes) if you’d rather record on Ubuntu and transcribe elsewhere. It doesn’t label speakers, and it transcribes after you stop recording rather than live.

Sharing transcripts without a cloud service #

Local transcription only stays private if the sharing does too. Some options that keep text on machines you control:

• Syncthing syncs a transcripts folder directly between teammates’ computers.
• A self-hosted Nextcloud or file server works if your company already runs one.
• A private Git repository on your own server works well for teams that live in Markdown.

Whatever you use, delete the raw audio once the transcript is checked. Text is small and easy to secure, while an hour of WAV is a large file with every voice in it. We cover the wider workflow in how to transcribe confidential meetings without cloud storage. For interviews rather than meetings, see how to transcribe interviews offline on Linux.

Tell your team you’re recording #

A local recording is still a recording. Say so at the start of the meeting, and check your company’s policy and local consent laws, which in some places require everyone’s agreement. Recording openly also tends to improve the transcript, because people are more likely to take turns.

Frequently asked questions #

Does this work on Ubuntu 22.04 and 24.04? #

Yes. The PipeWire and pactl commands work on 22.10 and later. Ubuntu 22.04 still ships PulseAudio by default, and the same pactl and ffmpeg -f pulse commands work there too. faster-whisper and whisper.cpp run on any current Ubuntu release.

Do I need an NVIDIA GPU? #

No. whisper.cpp and faster-whisper both run on a CPU. A GPU makes large models much faster, but on a CPU-only laptop “small” or “base.en” models still produce usable meeting notes, and you can run bigger models overnight.

How accurate is local Whisper for non-English meetings? #

Whisper’s multilingual models cover dozens of languages, and accuracy tracks how common the language was in training data. Major European and Asian languages do well, and smaller languages make more mistakes. Pin the language instead of relying on auto-detect when you know what people will speak.

Can I transcribe a Microsoft Teams or Zoom call on Linux? #

Yes. The recording method captures system audio, so it doesn’t matter which app the call runs in. Zoom’s desktop client can also save a local recording to your computer, which you can feed straight to faster-whisper or whisper.cpp. There’s more on that in our guide to private transcription for Zoom calls.