> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/voxtral-tts.md).

# Voxtral TTS

> **Mistrals Open-Weight-Text-to-Speech-Modell: 4 Mrd. Parameter, 9 Sprachen, Zero-Shot-Voice-Cloning, nur 3 GB VRAM.**

| Spezifikation        | Wert                                                                                                 |
| -------------------- | ---------------------------------------------------------------------------------------------------- |
| **Entwickler**       | Mistral AI                                                                                           |
| **Parameter**        | 4 Milliarden                                                                                         |
| **Architektur**      | Nur-Decoder-TTS                                                                                      |
| **Sprachen**         | 9 (Englisch, Französisch, Deutsch, Spanisch, Hindi, Arabisch, Portugiesisch, Italienisch, Japanisch) |
| **Lizenz**           | Apache 2.0 (Open Weights)                                                                            |
| **VRAM**             | \~3 GB (FP16)                                                                                        |
| **Latenz**           | 70 ms für 10 Sekunden Ausgabe                                                                        |
| **Stimmenklonen**    | Zero-Shot anhand einer 3-Sekunden-Referenz                                                           |
| **Veröffentlichung** | 26. März 2026                                                                                        |

## Warum Voxtral TTS?

Voxtral TTS ist Mistrals Antwort mit offenen Gewichten auf ElevenLabs und OpenAI TTS. Wichtige Vorteile für Clore.ai-Nutzer:

* **Läuft auf jeder GPU** — nur 3 GB VRAM bedeuten, dass sogar eine RTX 3060 perfekt funktioniert
* **Keine API-Gebühren** — selbst gehostet = unbegrenzte Synthese ohne variable Kosten
* **Datenschutz** — Audio verlässt niemals Ihr Gerät
* **Zero-Shot-Klonen** — klont jede Stimme aus 3 Sekunden Referenz-Audio
* **9 Sprachen nativ** — einschließlich Hindi und Arabisch, die bei Wettbewerbern oft fehlen
* **Echtzeit-Geschwindigkeit** — RTF 0,1–0,2× auf RTX 4070+ (10-Sekunden-Clip in 1–2 Sekunden)

## GPU-Anforderungen auf Clore.ai

| GPU           | VRAM  | Leistung                                         | Clore.ai-Preis |
| ------------- | ----- | ------------------------------------------------ | -------------- |
| RTX 3060 12GB | 12 GB | ✅ Gut — 3–4× Echtzeit                            | ab 0,10 $/Tag  |
| RTX 3090 24GB | 24 GB | ✅ Sehr gut — Batch-Verarbeitung                  | ab 0,30 $/Tag  |
| RTX 4070 12GB | 12 GB | ✅ Hervorragend — 5–10× Echtzeit                  | ab 0,25 $/Tag  |
| RTX 4090 24GB | 24 GB | ✅ Überdimensioniert — Latenz unter einer Sekunde | ab 0,50 $/Tag  |

> **Empfehlung:** Eine RTX 3060 12GB (0,10 $/Tag auf Clore.ai) ist für die meisten Anwendungsfälle der ideale Kompromiss. Voxtral benötigt nur 3 GB VRAM, sodass Sie es parallel zu anderen Modellen ausführen können.

## Schnellstart auf Clore.ai

### Schritt 1: GPU-Server mieten

1. Gehen Sie zu [Clore.ai Marketplace](https://clore.ai/marketplace)
2. Filtern Sie nach jeder GPU mit 8+ GB VRAM
3. Wählen Sie eine **Docker** Bereitstellung
4. Verwenden Sie das Image: `pytorch/pytorch:2.4.0-cuda12.4-cudnn9-devel`

### Schritt 2: Abhängigkeiten installieren

```bash
# Per SSH oder Jupyter-Terminal verbinden
pip install torch torchaudio transformers accelerate

# Voxtral-TTS-Paket installieren
pip install voxtral-tts

# Oder direkt HuggingFace verwenden
pip install huggingface_hub
huggingface-cli download mistralai/Voxtral-TTS --local-dir ./voxtral-tts
```

### Schritt 3: Einfache Text-zu-Sprache

```python
from voxtral import VoxtralTTS

# Modell initialisieren (Gewichte werden automatisch heruntergeladen, ~6 GB)
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS")
model.to("cuda")

# Einfache Synthese
audio = model.synthesize(
    text="Willkommen bei Clore.ai — dem dezentralen GPU-Marktplatz.",
    language="en"
)
audio.save("output.wav")
print(f"{audio.duration:.1f}s Audio erzeugt")
```

### Schritt 4: Zero-Shot-Voice-Cloning

```python
# Klont eine Stimme anhand einer 3-Sekunden-Referenz
audio = model.synthesize(
    text="Dies ist meine geklonte Stimme, die über GPU-Computing spricht.",
    reference_audio="reference_speaker.wav",  # 3+ Sekunden
    language="en"
)
audio.save("cloned_output.wav")
```

### Schritt 5: Mehrsprachige Synthese

```python
# Synthese in 9 unterstützten Sprachen
languages = {
    "en": "Hallo, hier spricht Voxtral auf Englisch.",
    "fr": "Bonjour, c'est Voxtral, das auf Französisch spricht.",
    "de": "Hallo, hier spricht Voxtral auf Deutsch.",
    "es": "Hola, Voxtral spricht auf Spanisch.",
    "hi": "नमस्ते, यह Voxtral हिंदी में बोल रहा है।",
    "ar": "مرحبا، هذا Voxtral يتحدث بالعربية.",
    "pt": "Olá, aqui é o Voxtral falando em português.",
    "it": "Ciao, qui parla Voxtral in italiano.",
    "ja": "こんにちは、Voxtralが日本語で話しています。",
}

for lang, text in languages.items():
    audio = model.synthesize(text=text, language=lang)
    audio.save(f"voxtral_{lang}.wav")
    print(f"[{lang}] {audio.duration:.1f}s erzeugt")
```

## Produktions-API-Server

Stellen Sie Voxtral als REST-API bereit, um es in Ihre Anwendungen zu integrieren:

```python
# server.py — FastAPI-Wrapper für Voxtral TTS
from fastapi import FastAPI, UploadFile, File
from fastapi.responses import StreamingResponse
from voxtral import VoxtralTTS
import io
import soundfile as sf

app = FastAPI(title="Voxtral TTS API")
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

@app.post("/synthesize")
async def synthesize(
    text: str,
    language: str = "en",
    reference: UploadFile = File(None)
):
    kwargs = {"text": text, "language": language}
    if reference:
        ref_bytes = await reference.read()
        kwargs["reference_audio"] = ref_bytes
    
    audio = model.synthesize(**kwargs)
    
    # Als WAV-Stream zurückgeben
    buffer = io.BytesIO()
    sf.write(buffer, audio.numpy(), samplerate=24000, format="WAV")
    buffer.seek(0)
    
    return StreamingResponse(buffer, media_type="audio/wav")

@app.get("/health")
async def health():
    return {"status": "ok", "model": "voxtral-tts", "languages": 9}
```

```bash
# API-Server starten
pip install fastapi uvicorn python-multipart soundfile
uvicorn server:app --host 0.0.0.0 --port 8000

# Testen
curl -X POST "http://localhost:8000/synthesize?text=Hallo%20Welt&language=en" \
  --output hello.wav
```

## Docker-Bereitstellung

```dockerfile
FROM pytorch/pytorch:2.4.0-cuda12.4-cudnn9-devel

WORKDIR /app
RUN pip install voxtral-tts fastapi uvicorn python-multipart soundfile

# Modellgewichte vorab herunterladen
RUN python -c "from voxtral import VoxtralTTS; VoxtralTTS.from_pretrained('mistralai/Voxtral-TTS')"

COPY server.py .
EXPOSE 8000
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8000"]
```

```bash
# Bauen und ausführen
docker build -t voxtral-tts-api .
docker run --gpus all -p 8000:8000 voxtral-tts-api
```

## Voxtral vs. andere TTS-Modelle

| Merkmal             | Voxtral TTS  | ElevenLabs    | Qwen3-TTS   | Kokoro TTS | Fish Speech  |
| ------------------- | ------------ | ------------- | ----------- | ---------- | ------------ |
| **Open Weights**    | ✅ Apache 2.0 | ❌ Nur API     | ✅           | ✅          | ✅            |
| **VRAM**            | 3 GB         | n. z. (Cloud) | 8 GB        | 2 GB       | 4 GB         |
| **Sprachen**        | 9            | 30+           | 50+         | 5          | 8            |
| **Stimmenklonen**   | 3s-Referenz  | 1s-Referenz   | 5s-Referenz | ❌          | 10s-Referenz |
| **Latenz**          | 70 ms        | \~200 ms      | \~150 ms    | 50 ms      | 100 ms       |
| **Qualität**        | ⭐⭐⭐⭐⭐        | ⭐⭐⭐⭐⭐         | ⭐⭐⭐⭐        | ⭐⭐⭐⭐       | ⭐⭐⭐⭐         |
| **Selbst gehostet** | ✅            | ❌             | ✅           | ✅          | ✅            |

## Batch-Verarbeitung für große Projekte

```python
import concurrent.futures
from voxtral import VoxtralTTS

model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")

# Ein ganzes Hörbuchkapitel verarbeiten
paragraphs = [
    "Kapitel 1: Der Anfang...",
    "Es war eine dunkle und stürmische Nacht...",
    "Der Protagonist trat vor...",
    # ... Hunderte von Absätzen
]

def process_paragraph(idx_text):
    idx, text = idx_text
    audio = model.synthesize(text=text, language="en")
    audio.save(f"chapter1_part{idx:04d}.wav")
    return idx

# Sequenzielle Verarbeitung (GPU-gebunden)
for i, text in enumerate(paragraphs):
    process_paragraph((i, text))
    
print(f"{len(paragraphs)} Absätze verarbeitet")
```

## Streaming-Modus für Echtzeitanwendungen

```python
# Streaming-Synthese für Live-Anwendungen
async def stream_synthesis(text: str, language: str = "en"):
    """Audio in Streaming-Blöcken für die Wiedergabe mit geringer Latenz erzeugen."""
    model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS").to("cuda")
    
    async for chunk in model.synthesize_stream(
        text=text,
        language=language,
        chunk_size=4096  # ~170 ms pro Chunk bei 24 kHz
    ):
        yield chunk.numpy().tobytes()
```

## Fehlerbehebung

| Problem                          | Lösung                                                                                                                     |
| -------------------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| OOM auf kleiner GPU              | Verwenden Sie `model.half()` für FP16 (halbiert die VRAM-Nutzung auf \~1,5 GB)                                             |
| Langsame erste Inferenz          | Normal — das Modell kompiliert beim ersten Lauf CUDA-Kerne (\~30 s)                                                        |
| Schlechte Qualität für Sprache X | Stellen Sie sicher, dass der richtige `Sprach` Parameter verwendet wird; einige Sprachen benötigen längeres Referenz-Audio |
| Audio-Artefakte                  | Erhöhen Sie die `reference_audio` Dauer auf 5–10 s für besseres Stimmenklonen                                              |
| Modell-Download schlägt fehl     | Setzen Sie die `HF_TOKEN` Umgebungsvariable für den Zugriff auf gesperrte Modelle                                          |

## Kostenanalyse: Voxtral auf Clore.ai vs. Cloud-TTS

| Dienst                   | 1 Mio. Zeichen/Monat | Hinweise                                               |
| ------------------------ | -------------------- | ------------------------------------------------------ |
| ElevenLabs Pro           | 99 $/Monat           | 500K Zeichen enthalten, Gebühren für Mehrverbrauch     |
| OpenAI TTS               | 15 $/Monat           | 15 $ pro 1 Mio. Zeichen                                |
| Google Cloud TTS         | 16 $/Monat           | Standardstimmen                                        |
| **Voxtral auf Clore.ai** | **3–15 $/Monat**     | RTX 3060 bei 0,10–0,50 $/Tag, unbegrenzt viele Zeichen |

> **Fazit:** Voxtral selbst auf Clore.ai zu hosten ist 6–30× günstiger als Cloud-TTS-APIs, mit keinen Zeichenlimits und vollständigem Datenschutz.

## Weiterlesen

* [Voxtral TTS auf HuggingFace](https://huggingface.co/mistralai/Voxtral-TTS)
* [Mistral AI Blog — Voxtral-Ankündigung](https://mistral.ai/news/voxtral-tts)
* [TTS-Modelle auf Clore.ai vergleichen](/guides/guides_v2-de/vergleiche/tts-comparison.md)
* [Weitere Audio- & Sprachleitfäden](/guides/guides_v2-de/audio-and-sprache/audio-voice.md)

***

*Zuletzt aktualisiert: 30. März 2026*


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/audio-and-sprache/voxtral-tts.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.