VoiceDeveloper

Posted on Sep 27

How to Clone Your Voice Using ElevenLabs API

#ai #webdev #javascript #tutorial

Introduction

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.

Prerequisites

What you need	Why it matters
Python 3.8+ (or Node.js)	To make HTTP calls to the API
`ffmpeg` installed	Converts raw recordings to the required WAV format
A microphone (any decent USB mic works)	ElevenLabs expects at least 10 seconds of clear speech
ElevenLabs API key	Authenticates your requests (see next section)

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.

Getting an API Key

Visit the signup page: https://try.elevenlabs.io/kr07zfuqn1bp.
Complete the quick registration (you’ll get a verification email).
Once logged in, navigate to API → Keys and click Create new key.
Copy the key—never commit it to a public repo. Store it in an environment variable, e.g. ELEVENLABS_API_KEY.

Recording Your Voice

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
# record.sh – captures 20 seconds of audio and saves it as voice_sample.wav
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.

Uploading & Training the Clone

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

Python Example

import os
import requests

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

# Step 1: Create a new voice placeholder
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}")

# Step 2: Upload the audio sample for training
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:

The /voices/add endpoint registers a new voice slot.
The /samples endpoint attaches your audio; the service begins training behind the scenes (usually under a minute).
You can list your voices later with GET https://api.elevenlabs.io/v1/voices.

Curl Alternative

# Create voice
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"}'

# Upload sample (replace <VOICE_ID> with the ID from the previous call)
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.

Synthesizing Speech with Your Clone

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}")

# Example usage
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.

Tips & Gotchas

Issue	Fix / Recommendation
Background noise	Record in a quiet room, use a pop filter, and keep the mic ~6 inches away.
Audio format errors	ElevenLabs expects mono 22 kHz WAV. `ffmpeg -ac 1 -ar 22050 input.mp3 voice.wav` does the trick.
Longer texts	The API caps at ~5 k characters per request. Split longer scripts into chunks and concatenate the resulting WAV files.
Rate limits	Free tier allows ~10 requests/minute. Cache generated audio if you need rapid repeats.
Voice similarity	Tweak `similarity_boost` (0–1). Higher values stick closer to the original sample but may sound a bit “stiff”.

Wrap‑Up

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!

DEV Community