> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/yocxy2/chatterboxyocxy/llms.txt
> Use this file to discover all available pages before exploring further.

# Quick Start

> Generate your first speech with Chatterbox TTS

This guide walks you through generating speech with all three Chatterbox models: Turbo, Original, and Multilingual.

## Choose Your Model

<Tabs>
  <Tab title="Turbo (Recommended)">
    **Chatterbox-Turbo** is the fastest and most efficient model, perfect for voice agents and production use. It features:

    * 350M parameters for lower VRAM usage
    * Native paralinguistic tags (`[laugh]`, `[chuckle]`, `[cough]`)
    * Single-step mel decoder for ultra-fast generation
    * English only
  </Tab>

  <Tab title="Original">
    **Chatterbox** is the original model with creative controls for expressive speech:

    * 500M parameters
    * Classifier-free guidance (CFG) tuning
    * Exaggeration controls
    * English only
  </Tab>

  <Tab title="Multilingual">
    **Chatterbox-Multilingual** supports 23+ languages with zero-shot voice cloning:

    * 500M parameters
    * Supports 23+ languages including Arabic, Chinese, French, German, Spanish, and more
    * Zero-shot voice cloning across languages
  </Tab>
</Tabs>

## Generate Your First Audio

<Steps>
  <Step title="Import the library">
    Import the necessary modules based on which model you want to use:

    <CodeGroup>
      ```python Turbo theme={null}
      import torchaudio as ta
      import torch
      from chatterbox.tts_turbo import ChatterboxTurboTTS
      ```

      ```python Original theme={null}
      import torchaudio as ta
      import torch
      from chatterbox.tts import ChatterboxTTS
      ```

      ```python Multilingual theme={null}
      import torchaudio as ta
      import torch
      from chatterbox.mtl_tts import ChatterboxMultilingualTTS
      ```
    </CodeGroup>
  </Step>

  <Step title="Load the model">
    Initialize the model with automatic device detection:

    <CodeGroup>
      ```python Turbo theme={null}
      # Load the Turbo model
      model = ChatterboxTurboTTS.from_pretrained(device="cuda")
      ```

      ```python Original theme={null}
      # Automatically detect the best available device
      if torch.cuda.is_available():
          device = "cuda"
      elif torch.backends.mps.is_available():
          device = "mps"
      else:
          device = "cpu"

      model = ChatterboxTTS.from_pretrained(device=device)
      ```

      ```python Multilingual theme={null}
      # Automatically detect the best available device
      if torch.cuda.is_available():
          device = "cuda"
      elif torch.backends.mps.is_available():
          device = "mps"
      else:
          device = "cpu"

      model = ChatterboxMultilingualTTS.from_pretrained(device=device)
      ```
    </CodeGroup>
  </Step>

  <Step title="Generate speech">
    Create audio from text:

    <CodeGroup>
      ```python Turbo theme={null}
      # Generate with Paralinguistic Tags
      text = "Oh, that's hilarious! [chuckle] Um anyway, we do have a new model in store."

      # Generate audio
      wav = model.generate(text)
      ```

      ```python Original theme={null}
      # English text
      text = "Ezreal and Jinx teamed up with Ahri, Yasuo, and Teemo to take down the enemy's Nexus in an epic late-game pentakill."

      # Generate audio
      wav = model.generate(text)
      ```

      ```python Multilingual theme={null}
      # French text
      text = "Bonjour, comment ça va? Ceci est le modèle de synthèse vocale multilingue Chatterbox, il prend en charge 23 langues."

      # Generate audio with language ID
      wav = model.generate(text, language_id="fr")
      ```
    </CodeGroup>

    <Tip>
      Turbo supports paralinguistic tags like `[laugh]`, `[chuckle]`, `[cough]` to add natural expressions to speech.
    </Tip>
  </Step>

  <Step title="Save the audio">
    Save the generated audio to a file:

    <CodeGroup>
      ```python Turbo theme={null}
      ta.save("output-turbo.wav", wav, model.sr)
      ```

      ```python Original theme={null}
      ta.save("output-english.wav", wav, model.sr)
      ```

      ```python Multilingual theme={null}
      ta.save("output-french.wav", wav, model.sr)
      ```
    </CodeGroup>
  </Step>
</Steps>

## Voice Cloning

All models support zero-shot voice cloning using a reference audio file. Provide an audio prompt to clone any voice:

<CodeGroup>
  ```python Turbo theme={null}
  # Generate with voice cloning
  text = "Hi there, Sarah here from MochaFone calling you back [chuckle]"
  wav = model.generate(text, audio_prompt_path="your_10s_ref_clip.wav")
  ta.save("cloned-voice.wav", wav, model.sr)
  ```

  ```python Original theme={null}
  # Generate with voice cloning
  text = "This will sound like the reference speaker"
  wav = model.generate(text, audio_prompt_path="YOUR_FILE.wav")
  ta.save("cloned-voice.wav", wav, model.sr)
  ```

  ```python Multilingual theme={null}
  # Generate with voice cloning in Chinese
  text = "你好，今天天气真不错，希望你有一个愉快的周末。"
  wav = model.generate(text, audio_prompt_path="YOUR_FILE.wav", language_id="zh")
  ta.save("cloned-voice-chinese.wav", wav, model.sr)
  ```
</CodeGroup>

<Note>
  For best results, use a reference audio clip that is 5-10 seconds long with clear speech and minimal background noise.
</Note>

## Complete Examples

Here are complete working examples for each model:

<CodeGroup>
  ```python Turbo theme={null}
  import torchaudio as ta
  import torch
  from chatterbox.tts_turbo import ChatterboxTurboTTS

  # Load the Turbo model
  model = ChatterboxTurboTTS.from_pretrained(device="cuda")

  # Generate with Paralinguistic Tags
  text = "Oh, that's hilarious! [chuckle] Um anyway, we do have a new model in store. It's the SkyNet T-800 series and it's got basically everything. Including AI integration with ChatGPT and all that jazz. Would you like me to get some prices for you?"

  # Generate audio
  wav = model.generate(text)
  ta.save("test-turbo.wav", wav, model.sr)
  ```

  ```python Original theme={null}
  import torchaudio as ta
  import torch
  from chatterbox.tts import ChatterboxTTS

  # Automatically detect the best available device
  if torch.cuda.is_available():
      device = "cuda"
  elif torch.backends.mps.is_available():
      device = "mps"
  else:
      device = "cpu"

  print(f"Using device: {device}")

  model = ChatterboxTTS.from_pretrained(device=device)

  text = "Ezreal and Jinx teamed up with Ahri, Yasuo, and Teemo to take down the enemy's Nexus in an epic late-game pentakill."
  wav = model.generate(text)
  ta.save("test-english.wav", wav, model.sr)
  ```

  ```python Multilingual theme={null}
  import torchaudio as ta
  import torch
  from chatterbox.mtl_tts import ChatterboxMultilingualTTS

  # Automatically detect the best available device
  if torch.cuda.is_available():
      device = "cuda"
  elif torch.backends.mps.is_available():
      device = "mps"
  else:
      device = "cpu"

  model = ChatterboxMultilingualTTS.from_pretrained(device=device)

  # French example
  french_text = "Bonjour, comment ça va? Ceci est le modèle de synthèse vocale multilingue Chatterbox, il prend en charge 23 langues."
  wav_french = model.generate(french_text, language_id="fr")
  ta.save("test-french.wav", wav_french, model.sr)

  # Chinese example
  chinese_text = "你好，今天天气真不错，希望你有一个愉快的周末。"
  wav_chinese = model.generate(chinese_text, language_id="zh")
  ta.save("test-chinese.wav", wav_chinese, model.sr)
  ```
</CodeGroup>

## Supported Languages (Multilingual Model)

The Multilingual model supports 23+ languages:

Arabic (ar) • Danish (da) • German (de) • Greek (el) • English (en) • Spanish (es) • Finnish (fi) • French (fr) • Hebrew (he) • Hindi (hi) • Italian (it) • Japanese (ja) • Korean (ko) • Malay (ms) • Dutch (nl) • Norwegian (no) • Polish (pl) • Portuguese (pt) • Russian (ru) • Swedish (sv) • Swahili (sw) • Turkish (tr) • Chinese (zh)

## Next Steps

* Learn about advanced features and tuning parameters
* Explore paralinguistic tags for Turbo
* Understand voice cloning best practices
* Check out the watermarking features for responsible AI