DEV Community

VoiceDeveloper
VoiceDeveloper

Posted on

Create an AI Podcast Generator with ElevenLabs

#ai #javascript #tutorial #webdev

Why an AI‑Generated Podcast?

Podcasts are exploding, but producing a high‑quality episode still means spending hours on scripting, recording, editing, and post‑production. What if you could automate most of that pipeline? With modern text‑to‑speech (TTS) and voice‑cloning tech, you can turn a plain text script into a polished, human‑like audio file in minutes. In this guide we’ll build a simple “AI Podcast Generator” that:

  1. Pulls a topic‑based script from an LLM (e.g., OpenAI’s GPT‑4).
  2. Sends the script to a TTS service that can mimic a natural voice.
  3. Saves the resulting audio and optionally stitches together multiple segments.

The star of the show is ElevenLabs, a cloud‑native TTS platform that delivers lifelike voice cloning. Their API is straightforward, affordable, and comes with a generous free tier—perfect for hobby projects and early‑stage prototypes. Grab your free trial here: https://try.elevenlabs.io/kr07zfuqn1bp.

Architecture Overview 

+----------------+      +-------------------+      +-------------------+
|   Prompt /    | ---> |  Generate Script  | ---> |  ElevenLabs TTS   |
|   Topic Input |      |  (LLM API)        |      |  (Audio Output)   |
+----------------+      +-------------------+      +-------------------+
                                      |
                                      v
                              +-------------------+
                              |  Post‑process     |
                              |  (concatenate,   |
                              |   metadata, etc.)|
                              +-------------------+
Enter fullscreen mode Exit fullscreen mode
  • LLM – We’ll use OpenAI’s chat/completions endpoint to create a 5‑minute script.
  • ElevenLabs TTS – Convert the script to speech using a cloned voice.
  • Post‑process – Optionally merge multiple segments, add intro/outro music, and export an MP3 ready for publishing.

Step 1: Get an ElevenLabs API Key

  1. Sign up (or log in) at https://try.elevenlabs.io/kr07zfuqn1bp.
  2. Navigate to API Keys in your dashboard.
  3. Copy the key; you’ll need it for every request.

Tip: Store the key in an environment variable (ELEVENLABS_API_KEY) instead of hard‑coding it.

Step 2: Generate a Podcast Script

Below is a minimal Python function that asks GPT‑4 to write a 5‑minute script about a given topic. You can swap the model or prompt to suit your niche.

import os
import json
import requests

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
HEADERS = {
    "Authorization": f"Bearer {OPENAI_API_KEY}",
    "Content-Type": "application/json"
}

def generate_script(topic: str) -> str:
    prompt = f"""You are a podcast host. Write a 5‑minute spoken script about **{topic}**.
    Include:
    - A 30‑second intro with a hook
    - 3 main talking points, each with a brief story or statistic
    - A 20‑second outro that invites listeners to subscribe.
    Keep the tone conversational and avoid bullet points."""

    data = {
        "model": "gpt-4o-mini",
        "messages": [{"role": "user", "content": prompt}],
        "temperature": 0.7
    }

    resp = requests.post(
        "https://api.openai.com/v1/chat/completions",
        headers=HEADERS,
        json=data,
    )
    resp.raise_for_status()
    return resp.json()["choices"][0]["message"]["content"]
Enter fullscreen mode Exit fullscreen mode

Result: generate_script("the future of renewable energy") returns a ready‑to‑read podcast script.

Step 3: Convert Text to Speech with ElevenLabs

ElevenLabs offers two convenient endpoints:

Endpoint Purpose
/v1/text-to-speech/{voice_id} One‑shot TTS (good for short scripts)
/v1/text-to-speech/{voice_id}/stream Streaming response (ideal for large scripts)

For a 5‑minute script, the streaming endpoint is more reliable. First, pick a voice ID from the dashboard (e.g., EXAVITQu4vr4xnSDxMaL). If you want a custom clone, follow ElevenLabs’ voice‑cloning flow and use the generated ID.

Python Example 

import os
import requests

ELEVEN_API_KEY = os.getenv("ELEVENLABS_API_KEY")
VOICE_ID = "EXAVITQu4vr4xnSDxMaL"  # replace with your voice ID

def synthesize(text: str, output_path: str = "episode.mp3"):
    url = f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE_ID}/stream"
    headers = {
        "xi-api-key": ELEVEN_API_KEY,
        "Content-Type": "application/json"
    }
    payload = {
        "text": text,
        "model_id": "eleven_monolingual_v1",  # default high‑quality model
        "voice_settings": {
            "stability": 0.75,
            "similarity_boost": 0.85
        }
    }

    # Stream the audio directly to a file
    with requests.post(url, headers=headers, json=payload, stream=True) as r:
        r.raise_for_status()
        with open(output_path, "wb") as f:
            for chunk in r.iter_content(chunk_size=8192):
                if chunk:
                    f.write(chunk)

    print(f"✅ Audio saved to {output_path}")
Enter fullscreen mode Exit fullscreen mode

Run it:

script = generate_script("the future of renewable energy")
synthesize(script, "renewable_energy_episode.mp3")
Enter fullscreen mode Exit fullscreen mode

You now have a 5‑minute MP3 that sounds like a real host.

Curl Alternative

If you prefer a quick terminal test, here’s a curl command that does the same thing:

curl -X POST "https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL/stream" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "text": "Your podcast script goes here...",
        "model_id": "eleven_monolingual_v1",
        "voice_settings": {"stability":0.75,"similarity_boost":0.85}
      }' --output episode.mp3
Enter fullscreen mode Exit fullscreen mode

Replace the placeholder script with the output from the LLM or read it from a file.

Step 4: Add Intro/Outro Music (Optional)

Most podcasts start with a short jingle. You can concatenate MP3s with pydub:

from pydub import AudioSegment

def add_jingles(main_path, intro_path="intro.mp3", outro_path="outro.mp3", out_path="final_episode.mp3"):
    intro = AudioSegment.from_file(intro_path)
    main = AudioSegment.from_file(main_path)
    outro = AudioSegment.from_file(outro_path)

    combined = intro + main + outro
    combined.export(out_path, format="mp3")
    print(f"✅ Final episode saved to {out_path}")

add_jingles("renewable_energy_episode.mp3")
Enter fullscreen mode Exit fullscreen mode

Make sure the sample rates match (most modern MP3s are 44.1 kHz, which pydub normalizes automatically).

Step 5: Automate the Whole Pipeline

Putting it all together in a single script makes generating new episodes a one‑liner.

def create_episode(topic: str, output="episode_final.mp3"):
    script = generate_script(topic)
    synth_path = "raw.mp3"
    synthesize(script, synth_path)
    add_jingles(synth_path, out_path=output)

if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("Usage: python generate.py \"topic\"")
    else:
        create_episode(sys.argv[1])
Enter fullscreen mode Exit fullscreen mode

Run:

python generate.py "how quantum computing will change AI"
Enter fullscreen mode Exit fullscreen mode

You’ll end up with a fully‑produced podcast episode ready for upload to your hosting platform.

Scaling Up: Batch Generation & Cloud Functions

When you start producing multiple episodes per week, consider:

  • Queueing – Push topics into a message queue (e.g., AWS SQS) and have a worker Lambda/Cloud Function process each item.
  • Storage – Store raw scripts and final MP3s in an S3 bucket for versioning.
  • Analytics – Log token usage from OpenAI and audio length from ElevenLabs to keep costs predictable.

All of these steps use the same core API calls we demonstrated, so you can keep the codebase small while the infrastructure grows.

Debugging Tips

Symptom Likely Cause Fix
401 Unauthorized from ElevenLabs Wrong or missing API key Verify ELEVENLABS_API_KEY env var and that the key isn’t expired.
Audio cuts off early Using the non‑stream endpoint for a long script Switch to /stream or split the script into < 2 KB chunks.
Garbled voice (robotic) Low stability or similarity_boost values Raise both to ~0.75‑0.9 for smoother output.
OpenAI returns empty script Prompt too vague or model throttled Add more explicit instructions or increase temperature.

What’s Next?

  • Dynamic voice selection – Let listeners pick a voice from a set of clones.
  • Transcription feedback loop – Run the generated audio through a speech‑to‑text API, compare with the original script, and auto‑correct mispronunciations.
  • Monetization – Insert pre‑rolled ads between segments using the same TTS pipeline.

The possibilities are limited only by your imagination (and token budget).

Try ElevenLabs Today!

If you’ve followed this tutorial, you already know how powerful ElevenLabs can be for turning plain text into broadcast‑quality audio. Their API is developer‑friendly, the pricing is transparent, and the quality rivals professional voice actors.

Ready to give your AI podcast a professional voice? Start your free trial now: https://try.elevenlabs.io/kr07zfuqn1bp. Happy coding, and may your podcasts be ever‑engaging!

Top comments (0)