Create Multilingual Voice Content with ElevenLabs

Why Multilingual Voice Matters for Modern Apps

You’re building a global product. Whether it’s a language‑learning app, a travel guide, or a customer‑support bot, people expect content in their native language. The old “text‑only” approach is no longer enough—users want to listen, not read. That’s where text‑to‑speech (TTS) and voice cloning come in.

A good TTS engine lets you generate on‑the‑fly audio from any text, while voice cloning gives you a personalized, brand‑consistent voice that can speak any language. If you want to scale to dozens of languages without hiring a new voice actor for each, you’ll need a platform that supports both features out of the box.

Enter ElevenLabs

ElevenLabs offers a cloud‑based TTS and voice‑cloning API that is:

• Multilingual – 30+ languages and accents are ready to use.
• High‑quality – Speech is natural, expressive, and can even mimic intonation.
• Developer‑friendly – Simple REST endpoints, SDKs, and plenty of documentation.
• Cost‑effective – Pay‑as‑you‑go pricing with a generous free tier.

If you’re looking to prototype or ship a multilingual voice feature, ElevenLabs is a solid starting point. You can sign up here: https://try.elevenlabs.io/kr07zfuqn1bp

Quick Start: Generate a Voice Clip in Python

Below is a minimal example that pulls a voice model, sends a text prompt, and streams back an MP3. It’s all you need to test the API before you build a full‑blown service.

import requests
import json

API_KEY = "YOUR_ELEVENLABS_API_KEY"
BASE_URL = "https://api.elevenlabs.io/v1"

# 1️⃣ Choose a voice model (English US, female)
voice_id = "EXAVITQu4vr4xnSDxMaL"

# 2️⃣ Prepare the text you want to convert
text = "안녕하세요! 여기는 한국어 테스트입니다. How are you today?"

# 3️⃣ Make the request
headers = {
    "xi-api-key": API_KEY,
    "Content-Type": "application/json",
}
payload = {
    "text": text,
    "voice_id": voice_id,
    "model_id": "eleven_monolingual_v1",
    "output_format": "mp3",
}

response = requests.post(f"{BASE_URL}/text-to-speech/{voice_id}", headers=headers, json=payload)

# 4️⃣ Save the audio
if response.status_code == 200:
    with open("output.mp3", "wb") as f:
        f.write(response.content)
    print("✅ Audio saved as output.mp3")
else:
    print(f"❌ Error: {response.status_code} – {response.text}")

What’s happening?

1. Voice ID – Each voice comes with a unique ID. You can list all available voices with /voices endpoint.
2. Model ID – ElevenLabs offers different models (monolingual, multilingual, etc.).
3. Output format – Choose mp3, wav, or raw PCM.
4. Streaming – For longer texts, you can enable streaming and process chunks in real time.

Feel free to swap the voice_id and text for any language you need. The API automatically detects language and adjusts pronunciation.

Building a Multilingual Chatbot with Voice Output

Let’s walk through a simple Flask app that accepts a user’s text, picks a language, and returns an audio response. This pattern scales to any framework or language.

from flask import Flask, request, send_file
import requests
import tempfile

app = Flask(__name__)
API_KEY = "YOUR_ELEVENLABS_API_KEY"
BASE_URL = "https://api.elevenlabs.io/v1"

@app.route("/speak", methods=["POST"])
def speak():
    data = request.json
    text = data.get("text")
    lang = data.get("lang", "en")  # default to English

    # 1️⃣ Get the voice ID for the requested language
    voices = requests.get(f"{BASE_URL}/voices", headers={"xi-api-key": API_KEY}).json()["voices"]
    voice = next((v for v in voices if lang in v["name"].lower()), None)
    if not voice:
        return {"error": f"No voice found for language: {lang}"}, 400

    # 2️⃣ Generate the audio
    payload = {
        "text": text,
        "voice_id": voice["voice_id"],
        "model_id": "eleven_monolingual_v1",
        "output_format": "mp3",
    }
    headers = {"xi-api-key": API_KEY}
    resp = requests.post(f"{BASE_URL}/text-to-speech/{voice['voice_id']}", headers=headers, json=payload)

    if resp.status_code != 200:
        return {"error": "TTS failed", "details": resp.text}, 500

    # 3️⃣ Return the audio file
    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
    tmp.write(resp.content)
    tmp.flush()
    return send_file(tmp.name, mimetype="audio/mpeg")

if __name__ == "__main__":
    app.run(debug=True)

How it works:

• The client sends JSON: { "text": "Hello world", "lang": "ko" }.
• The server queries the voice catalog, picks a Korean voice, and streams the MP3 back.
• The client can play the audio directly in a browser or mobile app.

Advanced Feature: Voice Cloning

If you want a brand‑specific voice or a custom narrator, ElevenLabs lets you clone a voice from just a few minutes of audio. The workflow is:

1. Upload a short audio clip (.wav or .mp3).
2. Wait for the model to process (usually a few minutes).
3. Use the newly generated voice_id in your TTS calls.

Here’s a curl example for uploading a clip:

curl -X POST "https://api.elevenlabs.io/v1/voices" \
     -H "xi-api-key: YOUR_ELEVENLABS_API_KEY" \
     -F "file=@/path/to/your/audio.wav" \
     -F "name=MyCustomVoice"

After the job finishes, you’ll receive a new voice_id. You can then pass it to the same /text-to-speech endpoint as shown earlier.

Tip: Keep your training audio clean, with minimal background noise, and speak clearly. The better the input, the more natural the clone.

Managing Costs and Latency

• Token‑based pricing: ElevenLabs charges per second of generated audio. For most apps, the cost is negligible compared to other cloud services.
• Caching: If you anticipate repeated phrases (e.g., “Welcome to the app”), cache the MP3 on your CDN. This reduces API calls and latency.
• Edge delivery: Store your audio in an edge cache (Cloudflare, Fastly) so users get instant playback no matter their location.

Integrating with Front‑End

Below is a quick React snippet that fetches an audio URL and plays it:

import React, { useState } from "react";

export default function VoicePlayer() {
  const [audioUrl, setAudioUrl] = useState("");

  const generate = async () => {
    const res = await fetch("/speak", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ text: "Hola, ¿cómo estás?", lang: "es" }),
    });
    const blob = await res.blob();
    setAudioUrl(URL.createObjectURL(blob));
  };

  return (
    <div>
      <button onClick={generate}>Speak Spanish</button>
      {audioUrl && <audio src={audioUrl} controls />}
    </div>
  );
}

Now your users can hear the same sentence in Spanish without leaving the page.

Security & Best Practices

• API key protection: Never expose your key in client code. Use a server proxy or environment variables.
• Rate limiting: ElevenLabs enforces per‑minute limits. Handle 429 responses gracefully by backing off or queueing requests.
• Compliance: If you’re handling user‑generated voice data for cloning, be sure to comply with GDPR, CCPA, and other privacy laws. ElevenLabs provides data‑processing addendums if needed.

Wrap‑Up

Multilingual voice is no longer a luxury—it’s a core part of the user experience for global products. By leveraging ElevenLabs’ TTS and voice‑cloning APIs, you can:

• Rapidly prototype in any language.
• Offer a consistent, branded voice across regions.
• Keep your stack lightweight—no need to host expensive speech models locally.

Ready to turn your text into natural, multilingual speech? Sign up today and get started with a free tier that lets you experiment without commitment.

Try ElevenLabs now: https://try.elevenlabs.io/kr07zfuqn1bp

Happy coding, and may your voices speak louder than words!