> 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-fr/audio-et-voix/voxtral-tts.md).

# Voxtral TTS

> **Le modèle de synthèse vocale open-weight de Mistral : 4 milliards de paramètres, 9 langues, clonage vocal zero-shot, seulement 3 Go de VRAM.**

| Spécification       | Valeur                                                                                |
| ------------------- | ------------------------------------------------------------------------------------- |
| **Développeur**     | Mistral AI                                                                            |
| **Paramètres**      | 4 milliards                                                                           |
| **Architecture**    | Synthèse vocale à décodeur uniquement                                                 |
| **Langues**         | 9 (anglais, français, allemand, espagnol, hindi, arabe, portugais, italien, japonais) |
| **Licence**         | Apache 2.0 (poids ouverts)                                                            |
| **VRAM**            | \~3 Go (FP16)                                                                         |
| **Latence**         | 70 ms pour une sortie de 10 secondes                                                  |
| **Clonage de voix** | Zero-shot à partir d'une référence de 3 secondes                                      |
| **Version**         | 26 mars 2026                                                                          |

## Pourquoi Voxtral TTS ?

Voxtral TTS est la réponse open-weight de Mistral à ElevenLabs et OpenAI TTS. Principaux avantages pour les utilisateurs de Clore.ai :

* **Fonctionne sur n'importe quel GPU** — seulement 3 Go de VRAM, ce qui signifie qu'une RTX 3060 fonctionne parfaitement
* **Pas de frais d'API** — auto-hébergé = synthèse illimitée à coût marginal nul
* **Confidentialité des données** — l'audio ne quitte jamais votre machine
* **Clonage zero-shot** — clonez n'importe quelle voix à partir de 3 secondes d'audio de référence
* **9 langues prises en charge nativement** — y compris l'hindi et l'arabe, souvent absents chez les concurrents
* **Vitesse en temps réel** — RTF de 0,1 à 0,2× sur RTX 4070+ (clip de 10 secondes en 1 à 2 secondes)

## Exigences GPU sur Clore.ai

| GPU            | VRAM  | Performances                                       | Prix Clore.ai             |
| -------------- | ----- | -------------------------------------------------- | ------------------------- |
| RTX 3060 12 Go | 12 Go | ✅ Bien — 3 à 4× en temps réel                      | à partir de 0,03–0,07 $/h |
| RTX 3090 24 Go | 24 Go | ✅ Très bien — traitement par lots                  | à partir de 0,07–0,21 $/h |
| RTX 4070 12 Go | 12 Go | ✅ Excellent — 5 à 10× en temps réel                | à partir de 0,04–0,20 $/h |
| RTX 4090 24 Go | 24 Go | ✅ Surdimensionné — latence inférieure à la seconde | à partir de 0,14–0,42 $/h |

> **Recommandation :** Une RTX 3060 12 Go (0,03–0,07 $/h sur Clore.ai) est le meilleur compromis pour la plupart des cas d'utilisation. Voxtral n'a besoin que de 3 Go de VRAM, vous pouvez donc l'exécuter en parallèle avec d'autres modèles.

## Démarrage rapide sur Clore.ai

### Étape 1 : Louez un serveur GPU

1. Accédez à [Marketplace Clore.ai](https://clore.ai/marketplace)
2. Filtrez pour n'importe quel GPU avec 8 Go ou plus de VRAM
3. Sélectionnez un **Docker** déploiement
4. Utilisez l'image : `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel`

### Étape 2 : Installez les dépendances

```bash
# Connectez-vous via SSH ou le terminal Jupyter
pip install torch torchaudio transformers accelerate

# Installez le package Voxtral TTS
pip install voxtral-tts

# Ou utilisez directement HuggingFace
pip install huggingface_hub
huggingface-cli download mistralai/Voxtral-TTS --local-dir ./voxtral-tts
```

### Étape 3 : Synthèse vocale de base

```python
from voxtral import VoxtralTTS

# Télécharge automatiquement les poids (~6 Go)
model = VoxtralTTS.from_pretrained("mistralai/Voxtral-TTS")
model.to("cuda")

# Synthèse de base
audio = model.synthesize(
    text="Bienvenue sur Clore.ai — la place de marché GPU décentralisée.",
    language="en"
)
audio.save("output.wav")
print(f"Généré {audio.duration:.1f}s d'audio")
```

### Étape 4 : Clonage vocal zero-shot

```python
# Clonez une voix à partir d'une référence de 3 secondes
audio = model.synthesize(
    text="C'est ma voix clonée qui parle de l'informatique GPU.",
    reference_audio="reference_speaker.wav",  # 3+ secondes
    language="en"
)
audio.save("cloned_output.wav")
```

### Étape 5 : Synthèse multilingue

```python
# Synthétisez dans 9 langues prises en charge
languages = {
    "en": "Bonjour, c'est Voxtral qui parle en anglais.",
    "fr": "Bonjour, c'est Voxtral qui parle en français.",
    "de": "Bonjour, c'est Voxtral qui parle en allemand.",
    "es": "Bonjour, c'est Voxtral qui parle en espagnol.",
    "hi": "Bonjour, c'est Voxtral qui parle en hindi.",
    "ar": "Bonjour, c'est Voxtral qui parle en arabe.",
    "pt": "Bonjour, c'est Voxtral qui parle en portugais.",
    "it": "Bonjour, c'est Voxtral qui parle en italien.",
    "ja": "Bonjour, c'est Voxtral qui parle en japonais.",
}

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

## Serveur API de production

Déployez Voxtral comme API REST pour l'intégrer à vos applications :

```python
# server.py — wrapper FastAPI pour 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="API Voxtral TTS")
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)
    
    # Retourner sous forme de flux WAV
    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
# Lancez le serveur API
pip install fastapi uvicorn python-multipart soundfile
uvicorn server:app --host 0.0.0.0 --port 8000

# Testez-le
curl -X POST "http://localhost:8000/synthesize?text=Bonjour%20le%20monde&language=en" \\
  --output hello.wav
```

## Déploiement Docker

```dockerfile
FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

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

# Pré-téléchargez les poids du modèle
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
# Construisez et lancez
docker build -t voxtral-tts-api .
docker run --gpus all -p 8000:8000 voxtral-tts-api
```

## Voxtral contre les autres modèles TTS

| Fonctionnalité      | Voxtral TTS  | ElevenLabs       | Qwen3-TTS | Kokoro TTS | Fish Speech |
| ------------------- | ------------ | ---------------- | --------- | ---------- | ----------- |
| **Poids ouverts**   | ✅ Apache 2.0 | ❌ API uniquement | ✅         | ✅          | ✅           |
| **VRAM**            | 3 Go         | N/D (cloud)      | 8 Go      | 2 Go       | 4 Go        |
| **Langues**         | 9            | 30+              | 50+       | 5          | 8           |
| **Clonage de voix** | réf. 3 s     | réf. 1 s         | réf. 5 s  | ❌          | réf. 10 s   |
| **Latence**         | 70 ms        | \~200 ms         | \~150 ms  | 50 ms      | 100 ms      |
| **Qualité**         | ⭐⭐⭐⭐⭐        | ⭐⭐⭐⭐⭐            | ⭐⭐⭐⭐      | ⭐⭐⭐⭐       | ⭐⭐⭐⭐        |
| **Auto-hébergé**    | ✅            | ❌                | ✅         | ✅          | ✅           |

## Traitement par lots pour les grands projets

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

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

# Traitez un chapitre entier de livre audio
paragraphs = [
    "Chapitre 1 : Le commencement...",
    "C'était une nuit noire et orageuse...",
    "Le protagoniste s'avança...",
    # ... des centaines de paragraphes
]

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

# Traitement séquentiel (limité par le GPU)
for i, text in enumerate(paragraphs):
    process_paragraph((i, text))
    
print(f"{len(paragraphs)} paragraphes traités")
```

## Mode de streaming pour les applications en temps réel

```python
# Synthèse en streaming pour les applications en direct
async def stream_synthesis(text: str, language: str = "en"):
    """Génère l'audio en segments en streaming pour une lecture à faible latence."""
    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 par segment à 24 kHz
    ):
        yield chunk.numpy().tobytes()
```

## Dépannage

| Problème                           | Solution                                                                                      |
| ---------------------------------- | --------------------------------------------------------------------------------------------- |
| OOM sur un petit GPU               | Utilisez `model.half()` pour FP16 (divise la VRAM par deux à \~1,5 Go)                        |
| Première inférence lente           | Normal — le modèle compile les noyaux CUDA au premier lancement (\~30 s)                      |
| Qualité médiocre pour la langue X  | Vérifiez le `language` langue ; certaines langues nécessitent un audio de référence plus long |
| Artefacts audio                    | Augmentez `audio de référence` allongez la durée à 5–10 s pour un meilleur clonage vocal      |
| Le téléchargement du modèle échoue | Définissez `HF_TOKEN` variable d'environnement pour l'accès au modèle protégé                 |

## Analyse des coûts : Voxtral sur Clore.ai par rapport aux TTS cloud

| Service                  | 1 M de caractères/mois | Remarques                                      |
| ------------------------ | ---------------------- | ---------------------------------------------- |
| ElevenLabs Pro           | 99 $/mois              | 500 k caractères inclus, frais de dépassement  |
| OpenAI TTS               | 15 $/mois              | 15 $ pour 1 M de caractères                    |
| Google Cloud TTS         | 16 $/mois              | Voix standard                                  |
| **Voxtral sur Clore.ai** | **3–15 $/mois**        | RTX 3060 à 0,03–0,07 $/h, caractères illimités |

> **En résumé :** L'auto-hébergement de Voxtral sur Clore.ai est 6 à 30 fois moins cher que les API TTS cloud, avec zéro limite de caractères et une confidentialité totale des données.

## Pour aller plus loin

* [Blog de Mistral AI — Annonce de Voxtral](https://huggingface.co/mistralai/Voxtral-TTS)
* [Comparer les modèles TTS sur Clore.ai](https://mistral.ai/news/voxtral-tts)
* [Comparer les modèles TTS sur Clore.ai](/guides/guides_v2-fr/comparaisons/tts-comparison.md)
* [Autres guides Audio et voix](/guides/guides_v2-fr/audio-et-voix/audio-voice.md)

***

*Dernière mise à jour : 30 mars 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/audio-et-voix/voxtral-tts.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.