F5-TTS einrichten: Stimme klonen in 12 Schritten [2026]

Wer heute eine synthetische Stimme braucht, landet fast automatisch bei ElevenLabs oder einem der anderen Cloud-Anbieter und schickt Audiodaten an einen fremden Server. Das kostet Geld, und für Firmen mit Datenschutzpflichten ist es oft ein Problem. F5-TTS geht den anderen Weg: Das Open-Source-Modell von Entwickler SWivid läuft komplett auf der eigenen GPU, klont eine Stimme aus wenigen Sekunden Referenzaudio und kostet nichts außer Strom. Version 1.1.22 erschien am 23. Juli 2026 und bildet die Basis für diese Anleitung. In 12 Schritten zeigen wir, wie die Installation unter Linux, Windows und macOS gelingt, wie deutsche Stimmen mit einem Community-Checkpoint funktionieren und wie ein fertiges Projekt am Ende aussieht.

Was ist F5-TTS und warum lohnt sich der lokale Betrieb?

F5-TTS steht für “A Fairytaler that Fakes Fluent and Faithful Speech with Flow Matching” und wurde erstmals 2024 im zugehörigen Forschungspapier auf arXiv beschrieben. Anders als klassische Sprachsynthese-Systeme braucht das Modell keinen separaten Phonemizer und kein kompliziertes Alignment zwischen Text und Audio. Stattdessen setzt es auf einen Diffusion-Transformer, der Text und ein kurzes Referenzaudio gemeinsam verarbeitet und daraus neue Sprache im Stil der Referenzstimme erzeugt.

Für das Klonen reicht laut Projektdokumentation ein Referenzclip zwischen 1 und 25 Sekunden Länge, kombiniert mit dem passenden Text. Ein Fine-Tuning der Zielstimme ist dafür nicht nötig, das unterscheidet F5-TTS von älteren Ansätzen wie klassischem Voice Cloning per Transferlernen. Auf einer einzelnen NVIDIA-L20-GPU misst das offizielle Repository im Client-Server-Modus mit zwei parallelen Anfragen eine durchschnittliche Latenz von 253 Millisekunden und einen Real-Time-Factor von 0,0394, gemessen über 26 Kombinationen aus Prompt-Audio und Zieltext. Ein Real-Time-Factor unter 1 bedeutet: Das System erzeugt Audio schneller, als es beim Abspielen vergeht. Im Offline-Betrieb mit TensorRT-LLM liegt der Wert bei 0,0402, mit reinem PyTorch bei 0,1467.

Technisch gesehen gehört F5-TTS zur Familie der Flow-Matching-Modelle, einer Weiterentwicklung klassischer Diffusionsmodelle. Statt Rauschen in vielen kleinen Schritten schrittweise zu entfernen, lernt das Modell direkt einen kontinuierlichen Pfad vom Rauschen zum Zielspektrogramm. In der Praxis bedeutet das weniger Rechenschritte bei ähnlicher Ausgabequalität, was die niedrigen Real-Time-Factor-Werte erklärt. Der nachgeschaltete Vocoder, standardmäßig Vocos, wandelt das erzeugte Spektrogramm anschließend in eine tatsächliche Audiowellenform um.

Ein weiterer Unterschied zu älteren TTS-Systemen betrifft die Trainingsdaten. Klassische Sprachsynthese brauchte für jede neue Stimme ein eigenes, stundenlanges Trainingsset mit sauber gelabelten Aufnahmen der jeweiligen Sprecherin oder des jeweiligen Sprechers. F5-TTS umgeht diesen Schritt komplett, weil das Basismodell bereits auf einem breiten Sprachkorpus trainiert wurde und beim eigentlichen Einsatz nur noch das Muster der Zielstimme aus dem kurzen Referenzclip übernimmt. Das erklärt, warum die Ergebnisqualität stark von der Sauberkeit dieses einen Referenzclips abhängt, während bei klassischem Training viele Stunden Material kleinere Fehler in einzelnen Aufnahmen ausgleichen konnten.

Der Kostenvergleich fällt eindeutig aus. Während ElevenLabs im Creator-Tarif rund 22 US-Dollar pro Monat verlangt, kostet die Software selbst bei F5-TTS 0 US-Dollar. Ausgaben entstehen nur für Hardware oder, wer keine eigene GPU hat, für gemieteten Cloud-Rechenraum. Für deutsche Nutzer kommt ein zweiter Punkt hinzu: Wenn die Verarbeitung lokal läuft, verlässt kein Sprachsample den eigenen Rechner. Das reduziert den Aufwand bei der DSGVO-Prüfung erheblich, weil kein Auftragsverarbeitungsvertrag mit einem externen TTS-Anbieter nötig wird.

Das macht F5-TTS für mehrere Zielgruppen interessant. Podcast-Produzenten nutzen es, um Intros und Outros ohne wiederholte Studiotermine zu vertonen. Firmen mit E-Learning-Inhalten sparen sich externe Sprecherbuchungen, wenn Kursmaterial regelmäßig aktualisiert werden muss. Entwicklerinnen und Entwickler binden es als Baustein in Sprachassistenten oder barrierefreie Anwendungen ein, etwa um Textinhalte für sehbehinderte Nutzer vorzulesen. Der gemeinsame Nenner ist immer derselbe: Kontrolle über die Stimme, ohne bei jedem Textabschnitt eine Rechnung an einen Cloud-Anbieter zu schicken.

Voraussetzungen: Hardware, Software und Python-Version

Bevor es losgeht, ein Blick auf die Anforderungen. F5-TTS läuft auf mehreren Plattformen, allerdings mit unterschiedlicher Geschwindigkeit. Die folgende Tabelle fasst zusammen, was für den Start nötig ist.

Komponente	Mindestanforderung	Empfehlung für flüssigen Betrieb
Python	Version 3.10	Version 3.11
GPU (NVIDIA)	Beliebige CUDA-fähige Karte	RTX-Karte mit aktuellem Treiber, PyTorch 2.8.0+cu128
GPU (AMD)	ROCm 6.x, nur Linux	ROCm 7.x für RDNA-3.5/4-Karten
GPU (Intel)	XPU-Build mit oneAPI-Toolkit	Aktuelles oneAPI-Base-Toolkit
Apple Silicon	Standard-PyTorch mit automatischer MPS-Erkennung	M-Serie-Chip mit 16 GB RAM
CPU-only	Wird unterstützt, aber deutlich langsamer	Nur für Tests, nicht für Produktivbetrieb
Modellgröße	Rund 1,35 GB für F5TTS_v1_Base	Genug freier Speicher im Hugging-Face-Cache
FFmpeg	Für Audio-Ein- und -Ausgabe erforderlich	Aktuelle Version aus Conda oder Systempaketquelle

Offizielle Mindestangaben zum VRAM-Bedarf veröffentlicht das Projekt nicht. Community-Anleitungen gehen davon aus, dass die reinen Modellgewichte rund 1,35 GB belegen und der Inferenzbetrieb mit Vocoder und optionaler Spracherkennung für die Transkription meist mit 6 bis 8 GB VRAM komfortabel läuft. Für eigenes Fine-Tuning nennen Setup-Guides 16 GB VRAM mit reduzierter Batch-Größe als realistische Untergrenze, etwa auf einer RTX 3090 oder 4090.

Die Python-Version verdient besondere Aufmerksamkeit, denn sie ist die häufigste Ursache für gescheiterte Installationsversuche. Systeme mit vorinstalliertem Python 3.9 oder älter scheitern bereits beim pip install, weil einige Abhängigkeiten von F5-TTS eine neuere Syntax voraussetzen. Eine dedizierte Conda-Umgebung umgeht dieses Problem zuverlässig, weil sie unabhängig von der Systemversion eine passende Python-Version mitbringt. Wer stattdessen venv nutzt, sollte vorab prüfen, welche Python-Version standardmäßig aufgerufen wird, da viele Distributionen weiterhin ältere Versionen als Standard hinterlegt haben.

Schritt 1 und 2: Conda-Umgebung, FFmpeg und PyTorch einrichten

Der erste Schritt legt eine saubere, isolierte Umgebung an. Das verhindert Versionskonflikte mit anderen Python-Projekten auf demselben Rechner. Wer noch kein Conda installiert hat, holt sich Miniconda von der offiziellen Seite und öffnet danach ein Terminal.

conda create -n f5tts python=3.11 -y
conda activate f5tts
conda install -c conda-forge ffmpeg -y
python --version
ffmpeg -version | head -n 1

Danach folgt die Installation von PyTorch, passend zur eigenen GPU. NVIDIA-Nutzer mit aktuellem Treiber greifen zur CUDA-12.8-Variante, ältere Systeme funktionieren meist noch mit der CUDA-12.4-Variante. Apple-Silicon-Nutzer installieren die Standardversion, PyTorch erkennt den M-Chip automatisch über den MPS-Backend.

# NVIDIA, aktueller Treiber
pip install torch==2.8.0+cu128 torchaudio==2.8.0+cu128 --extra-index-url https://download.pytorch.org/whl/cu128

# NVIDIA, älterer Treiber
pip install torch==2.4.0+cu124 torchaudio==2.4.0+cu124 --extra-index-url https://download.pytorch.org/whl/cu124

# macOS mit Apple Silicon
pip install torch torchaudio

Ein kurzer Test bestätigt, dass PyTorch die GPU tatsächlich sieht. Ohne diesen Check läuft F5-TTS später zwar trotzdem, aber auf der CPU und damit spürbar langsamer.

python -c "import torch; print(torch.cuda.is_available())"

Schritt 3 und 4: F5-TTS installieren und Modellgewichte laden

Mit funktionierender PyTorch-Installation folgt die eigentliche Installation von F5-TTS über pip. Wer am Quellcode mitarbeiten oder eigene Checkpoints trainieren möchte, klont stattdessen das Repository von GitHub und installiert im editierbaren Modus.

# Standardinstallation per pip
pip install f5-tts

# Alternative: Quellcode-Installation für Entwicklung
git clone https://github.com/SWivid/F5-TTS.git
cd F5-TTS
pip install -e .

Beim ersten Aufruf lädt F5-TTS die Gewichte des Standardmodells F5TTS_v1_Base automatisch von Hugging Face herunter und speichert sie im lokalen Cache-Verzeichnis unter ~/.cache/huggingface/hub. Auf einer normalen Leitung dauert das bei rund 1,35 GB nur wenige Minuten. Wer offline arbeiten will oder den Download vorab prüfen möchte, lädt die Datei manuell von der Hugging-Face-Seite herunter und legt sie im gleichen Verzeichnis ab.

Ein Blick auf die Projektstruktur hilft beim Verständnis, was die Installation tatsächlich anlegt. Nach dem ersten erfolgreichen Lauf entstehen typischerweise drei relevante Verzeichnisse: der Hugging-Face-Cache mit den Modellgewichten, ein lokaler Ordner für eigene Referenzaudios und ein Ausgabeordner für generierte Dateien. Wer mehrere Projekte parallel betreibt, etwa einen Podcast und ein E-Learning-Modul, sollte für jedes Projekt einen eigenen Unterordner für Referenz- und Ausgabedateien anlegen. Das verhindert, dass sich Referenzclips unterschiedlicher Sprecher versehentlich vermischen.

f5tts-projekt/
├── ref_audio/
│   ├── ref_audio_de.wav
│   └── ref_text_de.txt
├── output/
│   └── (generierte WAV-Dateien)
├── checkpoints/
│   └── german/
│       ├── model_last.pt
│       └── vocab.txt
└── episodentitel.txt

Schritt 5: Referenzaudio richtig vorbereiten

Die Qualität der geklonten Stimme hängt zu einem großen Teil vom Referenzclip ab. Die Projektdokumentation empfiehlt Aufnahmen zwischen 1 und 25 Sekunden Länge, in der Praxis liefern 8 bis 15 Sekunden meist die beste Balance zwischen Stimmtreue und Verarbeitungszeit. Ein paar Regeln machen den Unterschied zwischen einer brauchbaren und einer enttäuschenden Klonung:

• Sauberes Audio ohne Hintergrundmusik, Hall oder Rauschen verwenden
• Eine einzelne Sprecherin oder einen einzelnen Sprecher pro Clip aufnehmen
• WAV mit 16 oder 24 kHz Samplerate bevorzugen, MP3 funktioniert, klingt aber minimal schlechter
• Den exakten Wortlaut des Referenzclips als Text mitliefern, Abweichungen verwirren das Modell
• Neutrale Sprechweise ohne starke Emotion für die erste Testklonung wählen

Für die Aufnahme reicht in den meisten Fällen bereits ein einfaches USB-Mikrofon in einem ruhigen Raum, professionelles Studio-Equipment ist für die ersten Tests nicht nötig. Wichtiger als teure Hardware ist eine ruhige Umgebung ohne Nachhall, etwa ein kleines Zimmer mit Teppich, Vorhängen oder Möbeln statt eines leeren Raums mit harten Wänden. Wer keinen ruhigen Ort zur Verfügung hat, kann mit einem einfachen Noise-Gate in einer Audio-Software wie Audacity zumindest konstantes Hintergrundrauschen vor der Verarbeitung entfernen.

Für eigene Tests eignet sich ein kurzer Satz, mit dem Handy oder einem einfachen USB-Mikrofon aufgenommen. FFmpeg konvertiert bei Bedarf in das passende Format.

ffmpeg -i aufnahme_roh.m4a -ar 24000 -ac 1 ref_audio.wav

Schritt 6 und 7: Erste Stimmklonung über die Kommandozeile

Jetzt kommt der Teil, auf den alles hinausläuft: die erste synthetisierte Stimme. Der CLI-Befehl f5-tts_infer-cli nimmt Referenzaudio, den dazugehörigen Text und den neuen Zieltext entgegen und erzeugt daraus eine Audiodatei.

f5-tts_infer-cli \
  --model F5TTS_v1_Base \
  --ref_audio "ref_audio.wav" \
  --ref_text "Das ist meine Referenzaufnahme für die Stimmklonung." \
  --gen_text "Willkommen bei unserem Podcast über offene KI-Modelle." \
  --output_dir "output"

Das Ergebnis landet als WAV-Datei im angegebenen Ausgabeordner. Für mehrere Textabschnitte auf einmal akzeptiert die CLI auch eine Textdatei statt eines einzelnen Strings, jede Zeile wird dann als eigener Absatz behandelt und am Ende zu einer durchgehenden Audiodatei zusammengefügt.

f5-tts_infer-cli \
  --model F5TTS_v1_Base \
  --ref_audio "ref_audio.wav" \
  --ref_text "Das ist meine Referenzaufnahme für die Stimmklonung." \
  --gen_file "langtext.txt" \
  --output_dir "output"

Wer die Ausgabe feinjustieren will, greift auf zusätzliche Parameter zurück. Die wichtigsten fasst diese Tabelle zusammen.

Parameter	Funktion	Typischer Wert
–nfe_step	Anzahl der Diffusionsschritte, mehr Schritte = höhere Qualität, aber langsamer	16 bis 32
–speed	Sprechgeschwindigkeit der Ausgabe	1.0 als Standard
–cross_fade_duration	Überblendung zwischen Audiosegmenten bei langen Texten	0.15 Sekunden
–remove_silence	Entfernt lange Stillephasen aus der Ausgabe	Standardmäßig deaktiviert
–vocoder_name	Wahl des Vocoders, etwa Vocos oder BigVGAN	vocos

Für kurze Sätze reicht der Standardwert von 16 NFE-Schritten meist aus. Bei längeren Texten mit mehreren Sätzen lohnt sich ein Test mit 32 Schritten, die zusätzliche Rechenzeit fällt bei modernen GPUs kaum ins Gewicht.

Konsolenausgabe verstehen und Qualität bewerten

Nach dem CLI-Aufruf erscheint im Terminal ein Protokoll, das den Fortschritt der Verarbeitung zeigt. Wer die Ausgabe zum ersten Mal sieht, kann daran ablesen, ob GPU-Beschleunigung tatsächlich greift und wie lange die Generierung gedauert hat.

Loading model F5TTS_v1_Base...
Using device: cuda:0
Converting audio...
ref_audio duration: 9.42s
gen_text: "Willkommen bei unserem Podcast über offene KI-Modelle."
Generating audio with NFE steps: 16
100%|██████████| 16/16 [00:01<00:53, RTF: 0.041]
Saved output to output/infer_cli_out.wav (duration: 6.8s)

Drei Werte verdienen dabei besondere Aufmerksamkeit. Erstens die Zeile Using device: Steht dort cpu statt cuda oder mps, greift keine GPU-Beschleunigung, und die Verarbeitung dauert ein Vielfaches länger. Zweitens der RTF-Wert am Ende der Fortschrittsanzeige, er sollte für einen flüssigen Betrieb deutlich unter 1 liegen. Drittens die Ausgabedauer im Vergleich zum Zieltext: Wirkt die erzeugte Datei ungewöhnlich kurz oder lang im Verhältnis zur Textmenge, deutet das oft auf ein Problem mit dem Referenztext hin.

Für die klangliche Bewertung selbst hilft ein einfacher A/B-Test: Referenzaudio und generierte Ausgabe kurz hintereinander abspielen und auf drei Punkte achten. Stimmt die Tonlage grundsätzlich mit der Referenz überein? Klingt der Sprachfluss natürlich oder eher abgehackt? Und werden alle Wörter korrekt und verständlich ausgesprochen? Wenn eine der drei Fragen negativ ausfällt, hilft meist eine längere oder sauberere Referenzaufnahme, seltener ein höherer NFE-Wert.

Schritt 8: Deutsche Stimmen mit Community-Checkpoints

Das Basismodell F5TTS_v1_Base wurde primär mit englischem und chinesischem Material trainiert. Für deutsche Texte klingt die Ausgabe damit brauchbar, aber nicht makellos. Abhilfe schafft die deutsche Community rund um das Projekt Thorsten-Voice, das freie deutsche Sprachmodelle und Anleitungen zur lokalen Installation bereitstellt. Dort finden sich ein deutsches Vocab-File und Checkpoints, die speziell auf deutsche Phonetik abgestimmt sind.

Der Ablauf ähnelt der Standardinstallation, nur dass Modell- und Vocab-Datei manuell heruntergeladen und in das richtige Verzeichnis gelegt werden. Anschließend wird beim CLI-Aufruf der Pfad zum deutschen Checkpoint übergeben statt des Standardmodells.

f5-tts_infer-cli \
  --model_cfg "custom/german_model.yaml" \
  --ckpt_file "checkpoints/german/model_last.pt" \
  --vocab_file "checkpoints/german/vocab.txt" \
  --ref_audio "ref_audio_de.wav" \
  --ref_text "Dies ist eine deutsche Referenzaufnahme." \
  --gen_text "Heute testen wir die deutsche Aussprache von F5-TTS."

Der Unterschied in der Aussprache fällt bei Umlauten, dem ß und typisch deutschen Konsonantenclustern deutlich hörbar aus. Für professionelle deutschsprachige Projekte, etwa Podcast-Intros oder Erklärvideos, ist der deutsche Checkpoint fast immer die bessere Wahl.

Praxisbeispiele: Wofür Firmen und Einzelpersonen F5-TTS einsetzen

Die Bandbreite an Einsatzmöglichkeiten ist größer, als der Name Voice Cloning vermuten lässt. Im E-Learning-Bereich ersetzt F5-TTS wiederkehrende Studiotermine: Ändert sich ein Kursskript, wird nur der betroffene Absatz neu synthetisiert, statt die komplette Aufnahme mit einer Sprecherin oder einem Sprecher zu wiederholen. Podcast-Produzenten nutzen das Tool für Intros, Outros und Werbeeinblendungen, die sich schneller aktualisieren lassen als eine klassische Studioaufnahme.

Im Bereich Barrierefreiheit dient F5-TTS als Baustein für Vorlesefunktionen, etwa um Nachrichtenartikel oder interne Dokumente in einer konsistenten, vertrauten Stimme vorzulesen statt in einer generischen Systemstimme. Spieleentwicklerinnen und -entwickler testen es für Lokalisierung, um Dialogzeilen in mehreren Sprachen mit einer einheitlichen Figurenstimme zu erzeugen, bevor am Ende eine professionelle Synchronisation folgt. Und in der Softwareentwicklung selbst dient es als Testwerkzeug für Sprachanwendungen, weil sich beliebig viele Testsätze automatisiert generieren lassen, ohne für jeden Test eine echte Sprecherin zu buchen.

Auch im Marketing taucht F5-TTS zunehmend auf, etwa für personalisierte Sprachnachrichten in großer Zahl, bei denen ein Name oder eine Produktangabe im ansonsten identischen Text ausgetauscht wird. Da die Verarbeitung lokal läuft, lassen sich solche Kampagnen ohne laufende Nutzungsgebühren pro generierter Nachricht skalieren, ein Vorteil gegenüber Cloud-Diensten, die üblicherweise pro Zeichen oder pro Minute abrechnen. Wichtig bleibt dabei, dass die geklonte Stimme entweder die eigene ist oder mit ausdrücklicher Zustimmung der Sprecherin oder des Sprechers verwendet wird.

Sicherheit und Missbrauchsschutz beim Einsatz von Voice Cloning

Mit der Verbreitung von frei verfügbaren Voice-Cloning-Werkzeugen wächst auch das Missbrauchspotenzial, etwa für gefälschte Sprachnachrichten oder Betrugsanrufe. Wer F5-TTS in einem Unternehmenskontext einsetzt, sollte deshalb technische und organisatorische Schutzmaßnahmen mitdenken, nicht nur die reine Installation. Dazu gehört ein interner Prozess, der festlegt, wer Referenzaudio hochladen darf und wie die Einwilligung der geklonten Person dokumentiert wird.

Sinnvoll ist außerdem eine klare Kennzeichnung synthetisch erzeugter Audiodateien, etwa über Metadaten oder einen Hinweis im veröffentlichten Material. Die EU-KI-Verordnung sieht für als Deepfake erkennbare synthetische Inhalte grundsätzlich Transparenzpflichten vor, Details zur konkreten Umsetzung und den betroffenen Fällen sollten im Zweifel mit der eigenen Rechtsabteilung geklärt werden, da sich die Auslegung je nach Anwendungsfall unterscheiden kann. Wer die generierten Dateien intern archiviert, sollte zudem festhalten, welches Referenzaudio und welcher Text zu welcher Ausgabedatei gehören, falls später Rückfragen zur Herkunft einer Aufnahme auftauchen.

Ergänzend lohnt sich ein Blick auf technische Erkennungswerkzeuge für synthetische Sprache, die parallel zur eigenen Nutzung von F5-TTS eingesetzt werden können, um zu prüfen, ob fremdes Audiomaterial ebenfalls synthetisch erzeugt wurde. Solche Detektoren sind noch keine hundertprozentig verlässliche Lösung, liefern in der Praxis aber einen zusätzlichen Anhaltspunkt, wenn der Verdacht auf eine gefälschte Sprachaufnahme besteht, etwa bei verdächtigen Anrufen im Namen von Vorgesetzten oder Familienmitgliedern.

Schritt 9: Python-API in eigene Skripte einbinden

Für Automatisierung oder die Integration in eine größere Anwendung ist die CLI meist zu starr. F5-TTS bringt dafür eine Python-API mit, die sich direkt in eigenen Code einbauen lässt.

from f5_tts.api import F5TTS

tts = F5TTS(model="F5TTS_v1_Base")

wav, sr, spectrogram = tts.infer(
    ref_file="ref_audio.wav",
    ref_text="Das ist meine Referenzaufnahme für die Stimmklonung.",
    gen_text="Dieser Text wurde automatisiert mit F5-TTS erzeugt.",
    file_wave="output/api_ergebnis.wav",
    nfe_step=32,
)

print(f"Audio gespeichert, Samplerate: {sr} Hz")

Dieses Muster eignet sich für Batch-Verarbeitung, etwa wenn hunderte Textzeilen aus einer Datenbank automatisiert vertont werden sollen. Die Klasse F5TTS lädt das Modell einmal und kann danach mehrfach aufgerufen werden, ohne dass die Gewichte erneut geladen werden müssen. Das spart bei größeren Batches spürbar Zeit.

Bei produktivem Einsatz lohnt sich eine einfache Fehlerbehandlung um den Aufruf herum, damit ein einzelner fehlerhafter Textabschnitt nicht den kompletten Batch abbricht. Ein try-except-Block rund um tts.infer fängt typische Probleme ab, etwa eine beschädigte Referenzdatei oder eine zu lange Texteingabe, und protokolliert den Fehler statt das Skript zu beenden.

for text in textliste:
    try:
        tts.infer(
            ref_file="ref_audio.wav",
            ref_text=ref_text,
            gen_text=text,
            file_wave=f"output/{hash(text)}.wav",
        )
    except Exception as fehler:
        print(f"Fehler bei Text '{text[:30]}...': {fehler}")
        continue

Schritt 10: Gradio-Weboberfläche für den täglichen Einsatz

Nicht jeder möchte für jede Klonung ein Terminal öffnen. F5-TTS bringt eine Gradio-basierte Weboberfläche mit, die per Browser bedient wird und sich auch im lokalen Netzwerk für Kolleginnen und Kollegen freigeben lässt.

f5-tts_infer-gradio --port 7860 --host 0.0.0.0

Nach dem Start ist die Oberfläche unter http://localhost:7860 erreichbar, im lokalen Netzwerk unter der IP-Adresse des Rechners. Referenzaudio wird per Drag-and-Drop hochgeladen, der Zieltext in ein Textfeld eingegeben, ein Klick auf "Generate" startet die Verarbeitung. Für Teams ohne Kommandozeilen-Erfahrung ist das oft der praktischere Einstieg.

Die Oberfläche zeigt zusätzlich ein Spektrogramm der erzeugten Ausgabe an, was beim schnellen Vergleich mehrerer Varianten hilft, ohne jede Datei einzeln anhören zu müssen. Über ein Dropdown-Menü lässt sich außerdem zwischen installierten Modell-Checkpoints wechseln, etwa zwischen dem englischen Basismodell und einem deutschen Community-Checkpoint, ohne die Anwendung neu zu starten. Wer die Oberfläche im Team nutzt, sollte den Port hinter einer Firewall-Regel oder zumindest einem einfachen Passwortschutz betreiben, da die Standardkonfiguration ohne zusätzliche Absicherung startet.

Schritt 11: Docker-Container für den Produktivbetrieb

Wer F5-TTS auf einem Server betreiben oder in eine bestehende Infrastruktur einbetten will, fährt mit Docker meist sauberer als mit einer manuellen Installation, weil sich Python-Version, CUDA-Treiber und Abhängigkeiten in einem reproduzierbaren Image bündeln lassen statt bei jeder Serverneuinstallation erneut konfiguriert zu werden. Ein einfaches Setup sieht so aus:

git clone https://github.com/SWivid/F5-TTS.git
cd F5-TTS
docker build -t f5-tts:local .
docker run --gpus all -p 7860:7860 -v $(pwd)/output:/app/output f5-tts:local

Der Parameter --gpus all setzt eine funktionierende NVIDIA-Container-Toolkit-Installation voraus. Ohne GPU-Passthrough läuft der Container zwar, fällt aber auf CPU-Inferenz zurück und wird entsprechend langsam. Für den produktiven Einsatz auf einem Server ohne GPU lohnt sich eher ein kleinerer Batch-Modus über Nacht statt Echtzeit-Anfragen.

F5-TTS per REST-API in bestehende Workflows einbinden

Für viele Projekte reicht weder die CLI noch die Gradio-Oberfläche, weil andere Systeme direkt auf F5-TTS zugreifen sollen, etwa ein Content-Management-System oder eine interne Automatisierung. Ein schlanker Flask-Wrapper macht aus F5-TTS einen HTTP-Dienst, den beliebige Anwendungen per POST-Anfrage ansprechen können.

from flask import Flask, request, send_file
from f5_tts.api import F5TTS
import uuid

app = Flask(__name__)
tts = F5TTS(model="F5TTS_v1_Base")

@app.route("/generate", methods=["POST"])
def generate():
    daten = request.get_json()
    ziel_datei = f"output/{uuid.uuid4().hex}.wav"

    tts.infer(
        ref_file=daten["ref_audio"],
        ref_text=daten["ref_text"],
        gen_text=daten["gen_text"],
        file_wave=ziel_datei,
        nfe_step=32,
    )
    return send_file(ziel_datei, mimetype="audio/wav")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Dieser Wrapper lädt das Modell beim Start einmal und hält es im Arbeitsspeicher der GPU, statt es bei jeder Anfrage neu zu laden. Für den Produktivbetrieb empfiehlt sich davor noch ein Reverse Proxy wie Nginx sowie eine Authentifizierung über einen API-Key, da der Dienst sonst offen im Netzwerk erreichbar wäre. Wer die Last über mehrere Anfragen gleichzeitig verteilen will, startet mehrere Container-Instanzen hinter einem Load Balancer, jede mit eigenem GPU-Zugriff, statt eine einzelne Instanz mit paralleler Anfrageverarbeitung zu überlasten.

Schritt 12: Komplettes Projekt – automatisierter Podcast-Intro-Generator

Als Abschluss folgt ein kleines, aber vollständiges Projekt: ein Skript, das aus einer Textdatei mit Episodentiteln automatisch Podcast-Intros in der geklonten Stimme erzeugt und die Ergebnisse durchnummeriert ablegt. Das Beispiel zeigt, wie sich die einzelnen Bausteine aus den vorherigen Schritten zu einem funktionierenden Werkzeug zusammensetzen.

import os
from pathlib import Path
from f5_tts.api import F5TTS

REF_AUDIO = "ref_audio_de.wav"
REF_TEXT = "Dies ist eine deutsche Referenzaufnahme."
TITEL_DATEI = "episodentitel.txt"
AUSGABE_ORDNER = Path("intros")

def hauptprogramm():
    AUSGABE_ORDNER.mkdir(exist_ok=True)
    tts = F5TTS(model="F5TTS_v1_Base")

    with open(TITEL_DATEI, "r", encoding="utf-8") as datei:
        titel_liste = [zeile.strip() for zeile in datei if zeile.strip()]

    for index, titel in enumerate(titel_liste, start=1):
        text = f"Willkommen zu Episode {index}: {titel}."
        ziel_datei = AUSGABE_ORDNER / f"intro_{index:03d}.wav"

        tts.infer(
            ref_file=REF_AUDIO,
            ref_text=REF_TEXT,
            gen_text=text,
            file_wave=str(ziel_datei),
            nfe_step=32,
            speed=1.0,
        )
        print(f"Erzeugt: {ziel_datei}")

    print(f"Fertig: {len(titel_liste)} Intros in '{AUSGABE_ORDNER}' gespeichert.")

if __name__ == "__main__":
    hauptprogramm()

Eine Textdatei episodentitel.txt mit einem Titel pro Zeile reicht als Eingabe. Nach dem Start durchläuft das Skript jede Zeile, baut daraus einen kurzen Ansagetext und speichert das Ergebnis als eigene WAV-Datei. Bei zehn Episodentiteln und 32 NFE-Schritten auf einer Mittelklasse-GPU liegt die Gesamtlaufzeit meist im niedrigen einstelligen Minutenbereich, abhängig von Textlänge und Hardware.

Typische Konsolenausgabe nach einem erfolgreichen Durchlauf:

Erzeugt: intros/intro_001.wav
Erzeugt: intros/intro_002.wav
Erzeugt: intros/intro_003.wav
Fertig: 3 Intros in 'intros' gespeichert.

Die 5 häufigsten Fehler beim F5-TTS-Setup

Ein Blick auf typische Stolperfallen erspart Zeit bei der Fehlersuche. Diese fünf Punkte tauchen in Community-Foren und Support-Threads am häufigsten auf.

• Falsche PyTorch-CUDA-Version. Wer PyTorch ohne passende CUDA-Version installiert, bekommt zwar eine funktionierende Bibliothek, aber ohne GPU-Beschleunigung. Der Check mit torch.cuda.is_available() gehört deshalb direkt nach der Installation.
• Referenzaudio zu lang oder zu kurz. Clips unter einer Sekunde liefern zu wenig Information für die Klonung, Clips über 25 Sekunden werden oft automatisch gekürzt und verlieren dabei Kontext.
• Abweichender Referenztext. Wenn der angegebene ref_text nicht exakt dem gesprochenen Wort im Referenzaudio entspricht, verwechselt das Modell Phoneme und die Ausgabe klingt verzerrt.
• FFmpeg fehlt oder ist veraltet. Ohne funktionierendes FFmpeg schlägt die Audio-Ein- und -Ausgabe mit kryptischen Fehlermeldungen fehl, die selten direkt auf FFmpeg hindeuten.
• Falsches Modell für die Sprache gewählt. Wer deutsche Texte mit dem englischen Basismodell erzeugt, bekommt eine hörbar falsche Aussprache statt eines Fehlers, was die Ursache schwerer erkennbar macht.

Die meisten dieser Fehler fallen erst beim Anhören der fertigen Datei auf, nicht schon während der Installation. Es lohnt sich deshalb, nach jedem größeren Konfigurationsschritt eine kurze Testklonung mit einem bekannten Satz durchzuführen, statt erst am Ende eines längeren Batches zu prüfen, ob alles funktioniert hat.

Fehlerbehebung: 8 typische Probleme und ihre Lösungen

Auch bei sorgfältiger Installation tauchen gelegentlich Fehler auf. Die folgende Liste deckt die Probleme ab, die in Issues auf GitHub und in Community-Kanälen am häufigsten gemeldet werden.

• CUDA out of memory. Batch-Größe reduzieren oder nfe_step senken, alternativ kürzere Zieltexte in mehrere Aufrufe aufteilen.
• ModuleNotFoundError nach der Installation. Meist ein Zeichen dafür, dass die Conda-Umgebung nicht aktiviert wurde. Mit conda activate f5tts vor jedem Aufruf prüfen.
• Sehr langsame Inferenz auf der GPU. Häufig läuft PyTorch versehentlich im CPU-Modus. torch.cuda.is_available() liefert in diesem Fall False.
• Kein Ton oder stille Ausgabedatei. Oft liegt es an einer beschädigten oder leeren Referenzaudiodatei. Mit ffprobe ref_audio.wav lässt sich das prüfen.
• Roboterhafte oder abgehackte Aussprache. Der Wert für nfe_step ist meist zu niedrig. Ein Test mit 32 statt 16 Schritten verbessert die Qualität spürbar.
• Deutsche Umlaute werden falsch ausgesprochen. Ein Hinweis darauf, dass noch das englische Basismodell statt des deutschen Community-Checkpoints aktiv ist.
• Docker-Container startet ohne GPU-Zugriff. Die NVIDIA-Container-Toolkit-Installation fehlt oder ist veraltet, ein Neuinstallieren des Toolkits behebt das meist.
• Download der Modellgewichte bricht ab. Bei instabiler Verbindung hilft der manuelle Download von Hugging Face und das Ablegen der Datei im Cache-Verzeichnis, statt den automatischen Download erneut zu starten.

Wer nach diesen acht Punkten weiterhin auf ein Problem stößt, findet in den Issues des offiziellen GitHub-Repositorys meist bereits eine passende Diskussion, da die Community dort aktiv auf Fehlermeldungen reagiert. Ein Blick in die dortige Fehlerbeschreibung samt eigenem Stacktrace beschleunigt die Suche erheblich, gegenüber einer neuen Anfrage ohne Kontext.

Fortgeschrittene Tipps: Performance, Lizenz und Ethik

Wer F5-TTS über den Testbetrieb hinaus nutzt, profitiert von ein paar zusätzlichen Kniffen. Beim Batch-Betrieb lohnt es sich, das Modell einmal zu laden und dann mehrere Texte nacheinander zu verarbeiten, statt für jeden Text einen neuen Prozess zu starten. Das spart die Ladezeit der Modellgewichte, die bei wiederholten CLI-Aufrufen sonst jedes Mal neu anfällt.

Für lange Texte mit mehreren Absätzen hilft eine Aufteilung in einzelne Sätze, die getrennt synthetisiert und danach zusammengefügt werden. Der Parameter cross_fade_duration sorgt dabei für einen weichen Übergang zwischen den Segmenten, statt hörbarer Schnitte. Wer die Ausgabequalität weiter steigern will, testet unterschiedliche Vocoder: Vocos arbeitet schneller, BigVGAN liefert in manchen Fällen einen volleren Klang, kostet aber mehr Rechenzeit.

Beim Thema Lizenz und Ethik gilt: Open Source bedeutet nicht automatisch freie Hand. Der Code von F5-TTS ist frei verfügbar, das gibt aber keine Berechtigung, fremde Stimmen ohne Einwilligung zu klonen und zu veröffentlichen. Wer die Technik für Firmenprojekte einsetzt, sollte vorab die Einwilligung der jeweiligen Sprecherinnen und Sprecher einholen und dokumentieren. Für Deutschland kommt hinzu, dass eine Stimme als personenbezogenes Datum unter die DSGVO fallen kann, was zusätzliche Sorgfalt bei Speicherung und Verwendung der Referenzaufnahmen nahelegt.

Beim Speicherbedarf lohnt sich ein zweiter Blick auf die Präzision der Modellgewichte. Standardmäßig lädt F5-TTS die Gewichte in voller Genauigkeit, was auf GPUs mit wenig VRAM schnell eng werden kann. Eine Umstellung auf Halbpräzision reduziert den Speicherbedarf spürbar, kostet aber einen kleinen Teil der Ausgabequalität. Für Karten mit 8 GB VRAM oder weniger ist das oft der Unterschied zwischen einer laufenden und einer abstürzenden Installation.

import torch
from f5_tts.api import F5TTS

tts = F5TTS(model="F5TTS_v1_Base")
tts.ema_model = tts.ema_model.half()  # Halbpräzision für weniger VRAM-Verbrauch

Bei mehreren GPUs im selben Rechner lässt sich die Last aufteilen, indem für jede GPU ein eigener Prozess gestartet wird und die Umgebungsvariable CUDA_VISIBLE_DEVICES jeweils auf eine bestimmte Karte zeigt. Für eine einzelne GPU mit vielen Anfragen bringt Warteschlangen-Verarbeitung mehr als paralleles Starten mehrerer Prozesse, da sich sonst mehrere Modellkopien den gleichen Speicher teilen müssen und die Gesamtleistung eher sinkt als steigt.

F5-TTS im Vergleich zu anderen TTS-Lösungen

F5-TTS ist nicht die einzige Option für Sprachsynthese und Voice Cloning. Die folgende Tabelle stellt die wichtigsten Alternativen gegenüber, jeweils mit dem Fokus auf Kosten, Hosting und Referenzaudio-Anforderungen.

Lösung	Kosten	Hosting	Referenzaudio
F5-TTS	0 US-Dollar, Open Source	Lokal oder eigener Server	1 bis 25 Sekunden
ElevenLabs Creator	Rund 22 US-Dollar pro Monat	Cloud, Anbieter-Server	Wenige Sekunden bis Minuten
Coqui XTTS-v2	0 US-Dollar, Open Source	Lokal oder eigener Server	Ab rund 6 Sekunden
OpenAI TTS API	Nutzungsbasiert nach Zeichen	Cloud, Anbieter-Server	Kein direktes Voice Cloning aus Nutzeraudio

Der große Unterschied liegt nicht nur beim Preis, sondern bei der Kontrolle über die eigenen Daten. Cloud-Dienste wie ElevenLabs oder die OpenAI-TTS-API verarbeiten Sprachdaten auf fremden Servern, was für viele Anwendungsfälle völlig ausreicht, für sensible oder regulierte Branchen aber zusätzliche Prüfschritte erfordert. F5-TTS und Coqui XTTS-v2 laufen dagegen komplett lokal und sind damit die naheliegende Wahl, wenn Sprachdaten das eigene Netzwerk nicht verlassen sollen.

Welche Lösung am Ende passt, hängt vom konkreten Anwendungsfall ab. Wer nur gelegentlich einen kurzen Text vertonen will und keine eigene GPU besitzt, fährt mit einem Cloud-Dienst wie ElevenLabs meist einfacher, weil der komplette Installationsaufwand entfällt. Wer dagegen regelmäßig größere Textmengen verarbeitet, Wert auf Datenkontrolle legt oder die Kosten pro generierter Minute niedrig halten will, kommt an einer lokalen Lösung wie F5-TTS kaum vorbei. Zwischen F5-TTS und Coqui XTTS-v2 lohnt sich in der Praxis ein direkter Vergleich mit dem eigenen Referenzmaterial, da sich die Stärken je nach Zielsprache und Sprecherstimme unterscheiden können.

Updates im Blick behalten: Versionsverwaltung bei F5-TTS

Das Projekt wird aktiv weiterentwickelt, das GitHub-Repository verzeichnet zum Stand September 2026 mehr als 20 veröffentlichte Releases. Wer F5-TTS produktiv einsetzt, sollte deshalb gelegentlich prüfen, ob eine neuere Version verfügbar ist, da spätere Releases häufig Geschwindigkeitsverbesserungen oder Fehlerkorrekturen mitbringen.

# Installierte Version prüfen
pip show f5-tts

# Auf die neueste Version aktualisieren
pip install --upgrade f5-tts

# Bei Quellcode-Installation
cd F5-TTS
git pull origin main
pip install -e . --upgrade

Vor einem Update in einer produktiven Umgebung empfiehlt sich ein kurzer Test in einer separaten Conda-Umgebung, da sich CLI-Parameter oder das Verhalten der Python-API zwischen Versionen gelegentlich ändern. Ein Blick in die Release Notes auf GitHub zeigt vorab, ob ein Update breaking Changes enthält, bevor produktive Skripte betroffen sind.

Nach den 12 Schritten dieser Anleitung steht eine funktionierende F5-TTS-Installation samt CLI, Python-API, Web-Oberfläche und einem eigenen Automatisierungsskript für Podcast-Intros. Wer die deutschen Community-Checkpoints ergänzt, bekommt zusätzlich eine spürbar natürlichere Aussprache für deutschsprachige Projekte. Die wichtigsten Stellschrauben für die Praxis bleiben dabei überschaubar: eine saubere Referenzaufnahme, ein passender nfe_step-Wert und, bei GPU-Engpässen, die Umstellung auf Halbpräzision. Von hier aus lässt sich das Setup nach Bedarf erweitern, etwa um weitere Sprachmodelle, eine REST-Schnittstelle für bestehende Systeme oder einen mehrstufigen Docker-Aufbau für den Teamzugriff.

Häufig gestellte Fragen zu F5-TTS

Ist F5-TTS wirklich komplett kostenlos nutzbar?

Ja, der Code steht als Open Source zur Verfügung und die Software selbst verlangt keine Lizenzgebühr. Kosten entstehen nur für die verwendete Hardware oder für gemieteten Cloud-Rechenraum, falls keine eigene GPU vorhanden ist. Im Vergleich zu Abo-Modellen wie dem ElevenLabs-Creator-Tarif für rund 22 US-Dollar pro Monat rechnet sich eine vorhandene GPU bei regelmäßiger Nutzung meist bereits nach wenigen Monaten.

Funktioniert F5-TTS auch ohne dedizierte GPU?

Der CPU-Betrieb wird unterstützt, ist aber deutlich langsamer als mit GPU-Beschleunigung. Für gelegentliche Tests reicht eine CPU, für regelmäßige Nutzung oder Produktivbetrieb lohnt sich eine CUDA-, ROCm- oder Apple-Silicon-GPU.

Ist das Klonen fremder Stimmen mit F5-TTS legal?

Die Software selbst ist frei nutzbar, das Klonen einer fremden Stimme ohne Einwilligung der betroffenen Person kann jedoch Persönlichkeitsrechte verletzen und ist in vielen Fällen rechtlich problematisch. Für kommerzielle oder öffentliche Projekte sollte eine dokumentierte Einwilligung vorliegen, ergänzt um eine Kennzeichnung des Materials als synthetisch erzeugt, sobald der Inhalt veröffentlicht wird.

Welche Sprachen unterstützt F5-TTS?

Das Basismodell wurde vor allem mit englischem und chinesischem Material trainiert. Für Deutsch und andere Sprachen gibt es Community-Checkpoints wie das deutsche Modell von Thorsten-Voice, die eine deutlich bessere Aussprache liefern als das englische Standardmodell.

Wie lang muss die Referenzaufnahme mindestens sein?

Die Projektdokumentation nennt einen Bereich von 1 bis 25 Sekunden. In der Praxis liefern Aufnahmen zwischen 8 und 15 Sekunden meist die zuverlässigsten Ergebnisse.

Kann ich F5-TTS für kommerzielle Projekte einsetzen?

Der Code ist offen verfügbar, für die kommerzielle Nutzung lohnt sich trotzdem ein Blick in die aktuelle Lizenzdatei des Repositorys sowie in die Nutzungsbedingungen der jeweiligen Modell-Checkpoints, da sich Details zwischen Basismodell und Community-Checkpoints unterscheiden können.

Läuft F5-TTS auf einem Mac mit Apple Silicon?

Ja, die Standard-PyTorch-Installation erkennt M-Serie-Chips automatisch über das MPS-Backend. Die Geschwindigkeit liegt zwischen reiner CPU-Verarbeitung und einer dedizierten NVIDIA-GPU.

Wie unterscheidet sich F5-TTS von Coqui XTTS-v2?

Beide sind Open-Source-Lösungen für lokales Voice Cloning. F5-TTS setzt auf einen Diffusion-Transformer-Ansatz mit Flow Matching, XTTS-v2 nutzt eine andere Architektur. In der Praxis unterscheiden sich beide vor allem in Latenz und Natürlichkeit je nach Zielsprache, ein direkter Test mit eigenem Referenzmaterial zeigt am zuverlässigsten, welche Lösung für den jeweiligen Anwendungsfall besser passt.

Was mache ich, wenn die generierte Stimme nicht wie die Referenz klingt?

Meist liegt es an einer zu kurzen, verrauschten oder mehrsprachigen Referenzaufnahme. Eine neue, saubere Aufnahme von 10 bis 15 Sekunden mit exakt passendem Referenztext behebt das Problem in den meisten Fällen. Hilft das nicht, lohnt sich ein Test mit einem höheren nfe_step-Wert und, bei deutschen Texten, der Wechsel zum passenden Community-Checkpoint statt des englischen Basismodells.