Mit Whisper lokal per Docker verschriftlichst du Meetings, Interviews und Videos vollständig auf dem eigenen Server – ohne dass eine einzige Datei in die Cloud wandert. Diese Anleitung zeigt dir Schritt für Schritt, wie du Whishper (das Projekt pluja/whishper) per Docker Compose installierst. Whishper ist eine quelloffene, zu 100 % lokale Transkriptions- und Untertitel-Suite mit Web-UI, die faster-whisper als Backend nutzt und neben der App noch eine MongoDB für Metadaten sowie LibreTranslate für optionale Übersetzungen mitbringt. Zielgruppe sind Mittelstands-Admins und ambitionierte Heimserver-Nutzer, die Audio und Video DSGVO-konform ohne Cloud-Upload in Text und Untertitel (SRT/VTT) verwandeln wollen.

Kurzfassung: Verzeichnis anlegen, docker-compose.yml, .env und nginx.conf aus dem Repo laden, LibreTranslate-Ordner per chown 1032:1032 berechtigen, dann starten und die Web-UI öffnen. Die drei Kernbefehle:

curl -o docker-compose.yml https://raw.githubusercontent.com/pluja/whishper/main/docker-compose.yml \
 && curl -o .env https://raw.githubusercontent.com/pluja/whishper/main/example.env \
 && curl -o nginx.conf https://raw.githubusercontent.com/pluja/whishper/main/nginx.conf
mkdir -p ./whishper_data/libretranslate/{data,cache} && sudo chown -R 1032:1032 whishper_data/libretranslate
docker compose up -d   # danach: http://DEIN-SERVER:8082

Voraussetzungen

Bevor du startest, sollten Hardware und Software passen. Whishper ist grundsätzlich leichtgewichtig – je mehr CPU oder GPU du hast, desto schneller läuft die Transkription.

Server: Linux-Server mit Docker und Docker Compose (Debian 12 oder Ubuntu 24.04). Grundlagen dazu siehe verlinkte Compose-Anleitung weiter unten.
CPU/RAM: Für kleine Modelle (tiny, small) reichen ein paar GB RAM. Große Modelle (medium, large-v3) brauchen deutlich mehr RAM und sind auf reiner CPU spürbar langsamer.
GPU (optional): Eine NVIDIA-GPU beschleunigt große Modelle stark. Dafür brauchst du NVIDIA-Treiber und das nvidia-container-toolkit (siehe Schritt zur GPU).
Speicherplatz: Platz für die AI-Modelle (werden einmalig geladen) sowie deine Uploads und die Datenbank unter ./whishper_data/.
CPU-Hinweis: Sehr alte CPUs ohne AVX-Unterstützung (z. B. manche Synology-NAS) sind inkompatibel und brauchen Sonderkonfiguration.
Reverse-Proxy (empfohlen): Eine Domain plus Reverse-Proxy mit HTTPS, falls die UI von außen erreichbar sein soll – Whishper hat keine eingebaute Anmeldung.

Schritt 1: Projektverzeichnis und Compose-Dateien anlegen

Lege zuerst ein eigenes Verzeichnis für den Stack an und wechsle hinein. Dort landen später alle Konfigurationen und – über das Unterverzeichnis whishper_data/ – auch alle persistenten Daten.

mkdir -p /opt/whishper && cd /opt/whishper

# Compose, .env-Vorlage und nginx.conf aus dem Repo laden:
curl -o docker-compose.yml https://raw.githubusercontent.com/pluja/whishper/main/docker-compose.yml \
 && curl -o .env https://raw.githubusercontent.com/pluja/whishper/main/example.env \
 && curl -o nginx.conf https://raw.githubusercontent.com/pluja/whishper/main/nginx.conf

Die nginx.conf wird vom Whishper-Container intern verwendet – sie bündelt Frontend, Backend und die Transkriptions-API hinter einem Nginx. Du musst sie in der Regel nicht anfassen.

Wenn du es noch bequemer magst, gibt es ein offizielles Installationsskript. Es fragt interaktiv nach GPU-Nutzung, lädt bei Bedarf die GPU-Compose-Datei und legt .env sowie ./whishper_data/ für dich an:

curl -fsSL -o get-whishper.sh https://raw.githubusercontent.com/pluja/whishper/main/get-whishper.sh
bash get-whishper.sh

Schritt 2: Die compose.yaml verstehen und anpassen

Die offizielle docker-compose.yml definiert drei Dienste: die Whishper-App (Frontend, Backend und Transkriptions-API in einem Image hinter Nginx), MongoDB für Metadaten und LibreTranslate für Übersetzungen. So sieht eine vollständige, lauffähige CPU-Variante aus, die du direkt übernehmen kannst:

services:
  mongo:
    image: mongo
    env_file:
      - .env
    restart: unless-stopped
    volumes:
      - ./whishper_data/db_data:/data/db
      - ./whishper_data/db_data/logs/:/var/log/mongodb/
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${DB_USER:-whishper}
      MONGO_INITDB_ROOT_PASSWORD: ${DB_PASS:-whishper}
    expose:
      - 27017
    command: ['--logpath', '/var/log/mongodb/mongod.log']

  translate:
    container_name: whishper-libretranslate
    image: libretranslate/libretranslate:latest
    restart: unless-stopped
    env_file:
      - .env
    volumes:
      - ./whishper_data/libretranslate/data:/home/libretranslate/.local/share
      - ./whishper_data/libretranslate/cache:/home/libretranslate/.local/cache
    user: root
    tty: true
    environment:
      LT_DISABLE_WEB_UI: True
      LT_LOAD_ONLY: ${LT_LOAD_ONLY:-en,fr,es}
      LT_UPDATE_MODELS: True
    expose:
      - 5000
    healthcheck:
      test: ['CMD-SHELL', './venv/bin/python scripts/healthcheck.py']

  whishper:
    image: pluja/whishper:${WHISHPER_VERSION:-latest}
    env_file:
      - .env
    volumes:
      - ./whishper_data/uploads:/app/uploads
      - ./whishper_data/logs:/var/log/whishper
      - ./whishper_data/models:/app/models
      - ./nginx.conf:/etc/nginx/nginx.conf
    container_name: whishper
    restart: unless-stopped
    networks:
      default:
        aliases:
          - mongo
          - libretranslate
    ports:
      - 8082:80
    depends_on:
      - mongo
      - translate
    environment:
      PUBLIC_INTERNAL_API_HOST: ${WHISHPER_HOST}
      PUBLIC_TRANSLATION_API_HOST: ${WHISHPER_HOST}
      PUBLIC_API_HOST: ${WHISHPER_HOST:-}
      PUBLIC_WHISHPER_PROFILE: cpu
      WHISPER_MODELS_DIR: /app/models
      WHISPER_THREADS: ${CPU_THREADS:-4}
      ASR_MODEL_PATH: /app/models
      DB_PASS: ${DB_PASS:-whishper}
      DB_USER: ${DB_USER:-whishper}

Die wichtigsten Bausteine im Überblick:

Dienst	Image	Port	Zweck
whishper	`pluja/whishper:latest` (CPU) bzw. `:latest-gpu`	`8082:80`	Web-UI, Backend, Transkriptions-API
mongo	`mongo`	27017 (intern)	Metadaten/Datenbank
translate	`libretranslate/libretranslate:latest`	5000 (intern)	Übersetzungen (LibreTranslate)

Die persistente Ablage liegt komplett unter ./whishper_data/: uploads (deine Dateien), logs, models (die heruntergeladenen Whisper-Modelle), db_data (MongoDB) sowie libretranslate/data und libretranslate/cache. Dadurch überleben deine Daten jeden Container-Neustart und jedes Update.

Schritt 3: .env konfigurieren und Berechtigungen setzen

Öffne die .env und passe die zentralen Werte an. Hier legst du fest, welche Modelle vorgeladen werden, unter welcher Adresse die App erreichbar ist, welche Übersetzungssprachen LibreTranslate lädt und – ganz wichtig – die Datenbank-Zugangsdaten.

# Welche Whisper-Modelle beim Start verfuegbar sein sollen:
WHISPER_MODELS=tiny,small
# Adresse, unter der die UI erreichbar ist (Host:Port bzw. spaeter Domain):
WHISHPER_HOST=http://127.0.0.1:8082
# Welche Sprachen LibreTranslate laedt (Kommaliste, spart RAM):
LT_LOAD_ONLY=de,en,fr
# Datenbank-Login - vor Produktivbetrieb unbedingt aendern!
DB_USER=whishper
DB_PASS=BITTE-AENDERN
# CPU-Threads fuer die Transkription:
CPU_THREADS=4
# Optional fuer GPU-Image: WHISHPER_VERSION=latest-gpu

Ändere DB_PASS (und idealerweise DB_USER) unbedingt – die Vorgabe whishper/whishper ist ein bekanntes Standard-Passwort. Über WHISPER_MODELS steuerst du, welche Modelle vorab bereitstehen; weitere kannst du später in der UI pro Transkription nachladen.

Jetzt das LibreTranslate-Verzeichnis mit den korrekten Rechten anlegen. Das ist Pflicht: Ohne den passenden Owner 1032:1032 startet der LibreTranslate-Container mit Permission-Fehlern.

mkdir -p ./whishper_data/libretranslate/{data,cache} \
 && sudo chown -R 1032:1032 whishper_data/libretranslate

Schritt 4: Stack starten und Erststart beobachten

Starte den kompletten Stack im Hintergrund und verfolge die Logs. Der Erststart dauert typischerweise 2–5 Minuten, weil die AI-Modelle einmalig heruntergeladen werden. In dieser Zeit wirkt die UI scheinbar blockiert – nicht vorschnell neu starten, sondern die Logs beobachten.

docker compose up -d
docker compose logs -f      # Erststart 2-5 Min, Modelle werden geladen

Sobald die Modelle geladen sind, öffnest du die Web-UI im Browser:

http://DEIN-SERVER:8082

Wenn die Seite lädt und du das Whishper-Dashboard siehst, läuft der Stack. Ein kurzer Statuscheck zeigt dir, ob alle drei Container up sind:

docker compose ps

Schritt 5: Datei transkribieren und Untertitel exportieren

Die Ersteinrichtung läuft komplett über die Web-UI – es gibt keinen Login. So verschriftlichst du deine erste Datei:

Neue Transkription anlegen: Lade über die UI eine Audio- oder Videodatei hoch (z. B. eine Meeting-Aufnahme als meeting.mp3 oder video.mp4) oder gib eine URL an.
Modell wählen: Entscheide dich für eine Modellgröße. Faustregel: kleinere Modelle = schneller und sparsamer, large-v3 = beste Qualität, aber mehr RAM/VRAM und Rechenzeit.
Sprache festlegen: Wähle die Sprache der Aufnahme oder lass sie automatisch erkennen.
Transkribieren starten und den Fortschritt abwarten. Bei CPU-Betrieb und großen Modellen dauert das deutlich länger.
Bearbeiten und exportieren: Korrigiere den Text bei Bedarf im integrierten Untertitel-Editor und exportiere als TXT, JSON, SRT oder VTT.
Optional übersetzen: Über LibreTranslate kannst du das Transkript in eine der unter LT_LOAD_ONLY geladenen Sprachen übersetzen.

Hier die Orientierung zu den Modellgrößen:

Modell	Tempo	Ressourcen	Geeignet für
`tiny` / `base`	sehr schnell	sehr gering	schnelle Tests, klare Aufnahmen
`small`	schnell	gering	guter Kompromiss auf CPU
`medium`	mittel	höher	bessere Qualität, eher mit GPU
`large-v1`/`v2`/`v3`	langsam	hoch (VRAM/RAM)	beste Qualität, GPU empfohlen

Genau hier liegt der DSGVO-Vorteil: Sämtliche Verarbeitung passiert auf deinem Server, es gibt keinen Cloud-Upload. Meeting-Mitschnitte und sensible Interviews verlassen dein Netz nicht.

Schritt 6: GPU-Betrieb einrichten (optional)

Für große Modelle lohnt sich eine NVIDIA-GPU. Dafür installierst du zuerst das nvidia-container-toolkit und konfigurierst die Docker-Runtime. Auf Debian 12 / Ubuntu 24.04:

curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker && sudo systemctl restart docker

# Pruefen, ob die GPU sichtbar ist:
nvidia-smi

Whishper bringt dafür eine eigene docker-compose.gpu.yml mit. Sie nutzt das Image pluja/whishper:latest-gpu, dazu libretranslate/libretranslate:latest-cuda, setzt PUBLIC_WHISHPER_PROFILE: gpu und reserviert die GPU über den deploy-Block:

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Starte den Stack dann explizit mit der GPU-Compose-Datei:

docker compose -f docker-compose.gpu.yml up -d

Achte auf konsistente Tags: latest-gpu für Whishper und latest-cuda für LibreTranslate. Ein gemischter Betrieb (CPU-Image plus CUDA-LibreTranslate o. Ä.) führt zu Inkonsistenzen.

Schritt 7: Reverse-Proxy und Absicherung

Whishper hat keine eingebaute Authentifizierung: Die Web-UI auf Port 8082 ist offen erreichbar. Stelle die App daher niemals ungeschützt ins Internet. Setze einen Reverse-Proxy (z. B. Caddy, Traefik oder nginx) mit HTTPS und Basic-Auth bzw. SSO davor. Ein minimaler nginx-Reverse-Proxy mit Basic-Auth sieht so aus:

server {
    listen 443 ssl;
    server_name transkription.DEINE-DOMAIN.de;

    ssl_certificate     /etc/letsencrypt/live/DEINE-DOMAIN.de/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/DEINE-DOMAIN.de/privkey.pem;

    location / {
        auth_basic           "Whishper";
        auth_basic_user_file /etc/nginx/.htpasswd;

        proxy_pass http://127.0.0.1:8082;
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Weitere Härtung: Die Ports von MongoDB (27017) und LibreTranslate (5000) sollten nicht nach außen erreichbar sein. In der gezeigten Compose-Datei sind sie als expose nur intern verfügbar – falls du sie irgendwo per ports veröffentlichst, schränke sie per Firewall ein oder entferne das Mapping. Trage außerdem in der .env deine externe Adresse als WHISHPER_HOST ein, damit die UI-Links korrekt sind.

Schritt 8: Update und Backup

Updates laufen über den klassischen Compose-Weg. Beachte den Projekt-Hinweis: Auf dem eingefrorenen main-Branch kommen über latest aktuell keine neuen Features – der Befehl bleibt aber der richtige Workflow, sobald sich am Repo etwas tut.

docker compose pull
docker compose up -d
docker image prune -f       # alte Images aufraeumen

Für ein Backup stoppst du den Stack kurz (damit MongoDB konsistent ist) und sicherst das komplette Datenverzeichnis. Danach startest du wieder:

docker compose down
tar czf whishper-backup-$(date +%F).tar.gz ./whishper_data
docker compose up -d

Da alle persistenten Daten unter ./whishper_data/ liegen, genügt dieses eine Verzeichnis (plus docker-compose.yml, .env und nginx.conf) für ein vollständiges Wiederherstellen.

Alternative: faster-whisper-server / Speaches als API-Backend

Wenn du keine Web-Suite, sondern nur eine OpenAI-kompatible Transkriptions-API für eigene Skripte oder Anwendungen brauchst, ist das frühere faster-whisper-server die passende Alternative. Es wurde in Speaches umbenannt (Image ghcr.io/speaches-ai/speaches) und stellt eine /v1/audio/transcriptions-API auf Port 8000 bereit. Alte fedirz-Images und -Doku sind veraltet.

# CPU:
docker run --rm -d --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cpu

# GPU:
docker run --rm -d --gpus=all --publish 8000:8000 --name speaches \
  --volume hf-hub-cache:/home/ubuntu/.cache/huggingface/hub \
  ghcr.io/speaches-ai/speaches:latest-cuda

# Transkription testen:
curl http://localhost:8000/v1/audio/transcriptions \
  -F 'file=@meeting.mp3' \
  -F 'model=Systran/faster-whisper-large-v3'

Damit bindest du lokale Transkription direkt in Automatisierungen ein – etwa als selbst gehostete Alternative zu cloudbasierten Diensten.

Troubleshooting

LibreTranslate startet nicht / Permission-Fehler: Die Verzeichnisse whishper_data/libretranslate/{data,cache} brauchen den Owner 1032:1032. Per sudo chown -R 1032:1032 whishper_data/libretranslate korrigieren.
UI lädt nach dem Start nicht: Beim Erststart werden Modelle geladen (2–5 Min). Mit docker compose logs -f beobachten und nicht vorschnell neu starten.
GPU wird nicht genutzt: Prüfe mit nvidia-smi, ob die GPU sichtbar ist, ob das nvidia-container-toolkit installiert und die Docker-Runtime konfiguriert ist, und ob du wirklich mit -f docker-compose.gpu.yml startest.
Transkription extrem langsam: Auf reiner CPU sind medium und large-v3 sehr langsam und RAM-intensiv. Für Meetings small/medium wählen oder eine GPU nutzen.
Container startet auf altem NAS/Server nicht: CPUs ohne AVX (z. B. manche Synology-NAS) sind inkompatibel und brauchen Sonderkonfiguration.
Falscher Image-Tag: latest ist CPU, latest-gpu ist NVIDIA. Bei GPU zusätzlich libretranslate:latest-cuda verwenden, sonst entsteht eine Inkonsistenz.

Häufige Fragen

Werden meine Daten irgendwohin in die Cloud hochgeladen?

Nein. Whishper ist zu 100 % lokal: Sowohl die Transkription (faster-whisper) als auch die Übersetzung (LibreTranslate) laufen in deinen Containern auf deinem Server. Deine Audio- und Videodateien verlassen dein Netz nicht – das macht die Lösung für Meetings und Interviews DSGVO-konform.

Welche Modellgröße soll ich für Meetings nehmen?

Auf reiner CPU ist small ein guter Kompromiss aus Tempo und Qualität, bei mehr Anspruch medium. large-v3 liefert die beste Qualität, ist aber rechenintensiv und sollte eher mit GPU laufen. Du kannst Modelle pro Transkription in der UI wählen.

Brauche ich zwingend eine GPU?

Nein. CPU-Betrieb funktioniert, ist bei großen Modellen aber deutlich langsamer und RAM-intensiver. Eine NVIDIA-GPU plus nvidia-container-toolkit beschleunigt vor allem medium und large-v3 erheblich.

Welche Exportformate gibt es für Untertitel?

Whishper exportiert TXT, JSON sowie die Untertitelformate SRT und VTT. Vor dem Export kannst du das Transkript im integrierten Untertitel-Editor korrigieren.

Wie sichere ich Whishper gegen unbefugten Zugriff ab?

Die Web-UI hat keinen Login und ist auf Port 8082 offen erreichbar. Stelle einen Reverse-Proxy (Caddy, Traefik, nginx) mit HTTPS und Basic-Auth bzw. SSO davor, ändere die DB-Standardzugangsdaten und schränke die internen Ports von MongoDB und LibreTranslate per Firewall ein.

Ist Whishper noch aktiv in Entwicklung?

Der main-Branch ist eingefroren (letztes Release v3.1.4, September 2024), ein v4-Rewrite ist angekündigt. Die gezeigte Installation läuft stabil, erhält auf diesem Branch aber keine neuen Updates. Prüfe vor produktivem Dauereinsatz den aktuellen Repo-Status oder nutze für reine API-Zwecke Speaches.

Fazit

Mit Whishper und Docker Compose betreibst du eine vollständige, lokale Transkriptions- und Untertitel-Suite in unter einer halben Stunde: Verzeichnis anlegen, Compose-Dateien laden, LibreTranslate-Rechte setzen, starten – fertig. Über die Web-UI lädst du Audio oder Video hoch, wählst Modellgröße und Sprache und exportierst Untertitel als SRT oder VTT, optional sogar übersetzt. Auf reiner CPU reichen kleinere Modelle, für große Modelle bringt eine NVIDIA-GPU mit nvidia-container-toolkit spürbar Tempo. Wichtig bleiben drei Dinge: ändere die DB-Standardzugangsdaten, setze einen Reverse-Proxy mit HTTPS und Auth davor und behalte den eingefrorenen Repo-Status im Blick. Wer nur eine API braucht, greift zu Speaches. So verschriftlichst du Meetings und Videos zuverlässig und DSGVO-konform – komplett auf der eigenen Hardware.

Weiterführende Anleitungen und Quellen

Docker Compose: Grundlagen und Stacks – die Basis für Volumes, Ports und den Update-Workflow, den diese Anleitung nutzt.
LocalAI: OpenAI-kompatibler KI-Server mit Docker – passt zum Speaches-Ansatz, wenn du lokale KI-APIs selbst hosten willst.
Frigate: KI-Videoüberwachung (NVR) mit Docker – weiteres lokales KI-Projekt mit optionaler GPU-Beschleunigung.
Weitere Anleitungen in der Kategorie Künstliche Intelligenz.

Quellen: Whishper GitHub-Repository (pluja/whishper), Whishper-Doku – Installations-Guide, Whishper docker-compose.gpu.yml und Speaches (ehemals faster-whisper-server) – Installation.