# How Podcasters Use AI to Create Multilingual Episodes > Source: > Published: 2026-10-17 23:53:41+00:00 If you’ve ever tried to reach a global audience, you know that language can be a major barrier. Translating scripts, hiring voice actors for every dialect, and coordinating recordings across time zones can turn a simple podcast into a logistical nightmare. The good news? Voice‑AI and text‑to‑speech (TTS) tech have matured fast enough that you can generate high‑quality, native‑sounding episodes in any language with just a few lines of code. In this post, I’ll walk you through a practical workflow that shows how you can: And if you’re ready to get started, the tool that makes all of this possible is **ElevenLabs**. You can sign up and try it out here: [https://try.elevenlabs.io/kr07zfuqn1bp](https://try.elevenlabs.io/kr07zfuqn1bp) | Component | Why It Matters | |---|---| | **Python** | Easy to script and widely supported. | | **Google Cloud Translate** | Handles the heavy lifting of language conversion. | | **ElevenLabs API** | State‑of‑the‑art TTS + voice cloning. | | **FFmpeg** | Post‑processing (normalization, format conversion). | | **GitHub Actions** | Automate the whole pipeline from repo to feed. | You can swap out any of these for alternatives (Azure Translator, AWS Polly, etc.) but the example below sticks to the most developer‑friendly choices. The starting point is a clean text file (`episode.txt`) with the episode’s transcript in your native language. You can add metadata (title, tags) in YAML front‑matter if you like, but the core is plain text. ``` Title: The Future of AI in Healthcare Episode: 12 Author: Jane Doe --- Today we’re talking about how AI is transforming diagnostics, treatment plans, and patient care... ``` We’ll use the Google Cloud Translate API because it’s straightforward and offers a generous free tier. Here’s a quick wrapper: ``` python # translate.py from google.cloud import translate_v1 as translate def translate_text(text, target_lang): client = translate.Client() result = client.translate(text, target_language=target_lang) return result["translatedText"] ``` Call it for each language you want: ``` languages = ["es", "fr", "de"] # Spanish, French, German translations = {lang: translate_text(script_text, lang) for lang in languages} ``` ElevenLabs gives you two key features: Below is a minimal example that uses the clone feature. Remember to replace `YOUR_API_KEY` with the key you get after signing up. ``` python # eleven.py import requests import json API_KEY = "YOUR_API_KEY" BASE_URL = "https://api.elevenlabs.io/v1" def synthesize(text, voice_id, model_id="eleven_monolingual_v1"): headers = { "xi-api-key": API_KEY, "Content-Type": "application/json" } payload = { "text": text, "voice_settings": {"stability": 0.75, "similarity_boost": 0.75}, "model_id": model_id, "voice_id": voice_id } response = requests.post(f"{BASE_URL}/text-to-speech/{voice_id}/stream", headers=headers, json=payload, stream=True) response.raise_for_status() return response.raw def save_audio(stream, filename): with open(filename, "wb") as f: for chunk in stream.iter_content(chunk_size=4096): if chunk: f.write(chunk) ``` **Using the clone voice** ``` python # main.py from eleven import synthesize, save_audio from translate import translate_text script_text = open("episode.txt").read() languages = ["es", "fr", "de"] voice_id = "YOUR_CLONED_VOICE_ID" # obtained after training for lang in languages: translated = translate_text(script_text, lang) audio_stream = synthesize(translated, voice_id) save_audio(audio_stream, f"episode_{lang}.mp3") ``` **Tip:** If you haven’t cloned a voice yet, visit [https://try.elevenlabs.io/kr07zfuqn1bp](https://try.elevenlabs.io/kr07zfuqn1bp) to start the process. ElevenLabs offers a generous free trial, so you can experiment with a few voices before committing. After you’ve got the raw MP3s, a quick FFmpeg pass normalizes volume and converts to a podcast‑friendly format. ``` for file in episode_*.mp3; do ffmpeg -i "$file" -af "loudnorm=I=-16:TP=-1.5:LRA=11" "${file%.mp3}.wav" done ``` The `loudnorm` filter ensures every episode sits at the same perceived loudness, a requirement for many podcast directories. Commit your script, translation configs, and a tiny workflow file and you’ll have a fully automated pipeline. ``` # .github/workflows/podcast.yml name: Generate Podcast on: push: branches: [main] paths: ["episode.txt"] jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - name: Set up Python uses: actions/setup-python@v5 with: python-version: "3.11" - name: Install dependencies run: pip install google-cloud-translate requests - name: Run pipeline env: ELEVEN_API_KEY: ${{ secrets.ELEVEN_API_KEY }} run: | python main.py - name: Upload to S3 uses: jakejarvis/s3-sync-action@master with: args: --acl public-read env: AWS_S3_BUCKET: ${{ secrets.S3_BUCKET }} AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} ``` All you need to do is push a new `episode.txt`, and the action will produce the translated audio, upload it, and you can link the files in your RSS feed. | Tip | Why It Helps | |---|---| | **Keep transcripts concise** | Shorter texts translate faster and reduce API costs. | | **Use the “story” voice** | ElevenLabs offers voices tuned for narrative flow. | | **Test translations locally** | Spot awkward phrasing before generating audio. | | **Cache translations** | Re‑using the same text in multiple episodes saves compute. | | **Add a fallback voice** | If the clone fails, fall back to a generic voice to keep the pipeline running. | Creating multilingual podcast episodes used to be a nightmare involving multiple editors, voice actors, and a lot of manual QA. With modern TTS services like ElevenLabs, you can: All that remains is to drop a text file into your repo and let the pipeline do the heavy lifting. If you’re ready to experiment, sign up at [https://try.elevenlabs.io/kr07zfuqn1bp](https://try.elevenlabs.io/kr07zfuqn1bp), create a clone voice, and watch your podcast reach a global audience in a fraction of the time. Happy podcasting!