How to Clone Your Voice Using ElevenLabs API

Ever wanted to hear your voice read out a blog post, generate a podcast, or add a personal touch to a chatbot? With the rise of neural text‑to‑speech (TTS) services, voice cloning has gone from a research demo to a practical tool you can use in minutes. In this article I’ll walk you through the whole pipeline—recording a few seconds of audio, sending it to the ElevenLabs API, and finally generating speech that sounds just like you. By the end you’ll have a reusable script you can drop into any Python or JavaScript project.

Why ElevenLabs?

The platform offers a generous free tier, low‑latency neural models, and a clean REST API that’s perfect for rapid prototyping. You can sign up and get your API key instantly through this affiliate link: https://try.elevenlabs.io/kr07zfuqn1bp.

If you prefer JavaScript, the same endpoints work with fetch or axios. I’ll show a quick curl example too, so you can choose whichever language fits your stack.

ELEVENLABS_API_KEY. ElevenLabs recommends 10–30 seconds of clean, single‑speaker audio. Here’s a minimal Bash script that uses ffmpeg to capture a 20‑second clip:

#!/usr/bin/env bash
ffmpeg -f avfoundation -i ":0" -t 20 -ac 1 -ar 22050 voice_sample.wav

Replace :0 with the appropriate device identifier on your OS (-i default works on Linux).

Make sure you speak naturally, avoid background noise, and keep the microphone at a consistent distance.

ElevenLabs calls the process “Voice Cloning”. You upload your sample, and the service creates a new voice ID you can reuse.

import os
import requests

API_KEY = os.getenv("ELEVENLABS_API_KEY")
VOICE_NAME = "my-clone"
AUDIO_PATH = "voice_sample.wav"

create_url = "https://api.elevenlabs.io/v1/voices/add"
headers = {
    "xi-api-key": API_KEY,
    "Content-Type": "application/json"
}
payload = {
    "name": VOICE_NAME,
    "description": "My personal cloned voice"
}
resp = requests.post(create_url, json=payload, headers=headers)
resp.raise_for_status()
voice_id = resp.json()["voice_id"]
print(f"Created voice ID: {voice_id}")

upload_url = f"https://api.elevenlabs.io/v1/voices/{voice_id}/samples"
files = {"sample": open(AUDIO_PATH, "rb")}
resp = requests.post(upload_url, headers={"xi-api-key": API_KEY}, files=files)
resp.raise_for_status()
print("Sample uploaded – training will start automatically.")

A few things to note:

/voices/add``/samples`` GET https://api.elevenlabs.io/v1/voices.

curl -X POST "https://api.elevenlabs.io/v1/voices/add" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name":"my-clone","description":"My personal cloned voice"}'

curl -X POST "https://api.elevenlabs.io/v1/voices/<VOICE_ID>/samples" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -F "sample=@voice_sample.wav"

After the upload, check the voice status:

curl -s -H "xi-api-key: $ELEVENLABS_API_KEY" \
  "https://api.elevenlabs.io/v1/voices/<VOICE_ID>" | jq .

When "status": "ready" appears, you’re good to go.

Now that the voice is ready, generating audio is a one‑liner.

def synthesize(text: str, voice_id: str, output_path: str = "out.wav"):
    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
    payload = {
        "text": text,
        "model_id": "eleven_monolingual_v1",  # default high‑quality model
        "voice_settings": {"stability": 0.75, "similarity_boost": 0.85}
    }
    headers = {"xi-api-key": API_KEY, "Content-Type": "application/json"}
    resp = requests.post(url, json=payload, headers=headers, stream=True)
    resp.raise_for_status()
    with open(output_path, "wb") as f:
        for chunk in resp.iter_content(chunk_size=8192):
            f.write(chunk)
    print(f"Saved: {output_path}")

synthesize(
    text="Hey there! This is my own voice reading a paragraph.",
    voice_id=voice_id,
    output_path="my_voice_demo.wav"
)

If you prefer JavaScript, the same request works with fetch:

const fetch = require('node-fetch');
const fs = require('fs');
const API_KEY = process.env.ELEVENLABS_API_KEY;
const voiceId = '<YOUR_VOICE_ID>';

async function synthesize(text) {
  const response = await fetch(
    `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`,
    {
      method: 'POST',
      headers: {
        'xi-api-key': API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        text,
        model_id: 'eleven_monolingual_v1',
        voice_settings: { stability: 0.75, similarity_boost: 0.85 }
      })
    }
  );

  const buffer = await response.buffer();
  fs.writeFileSync('js_demo.wav', buffer);
  console.log('Saved js_demo.wav');
}

synthesize('Hello from my cloned voice!');

Play back my_voice_demo.wav (or js_demo.wav) and you’ll hear a surprisingly natural rendition of your own speech.

Voice cloning with ElevenLabs is surprisingly straightforward: record a short sample, upload it, wait for the model to train, and then call the TTS endpoint whenever you need. Because the API is REST‑ful, you can embed it in anything from a CLI tool to a full‑stack web app or a serverless function.

If you’re building a podcast generator, an interactive voice assistant, or just want to add a personal flair to your notifications, give it a spin. The learning curve is shallow, the latency is low, and the results are impressive enough to wow both teammates and end users.

Ready to hear your own voice in code? Grab your free ElevenLabs API key via https://try.elevenlabs.io/kr07zfuqn1bp, follow the steps above, and start synthesizing today. Happy hacking!