DEV Community: VoiceDeveloper

Using AI Voice for E-Commerce Product Descriptions

VoiceDeveloper — Sat, 26 Sep 2026 15:37:08 +0000

Why AI Voice Matters for E‑Commerce

Picture this: a shopper is scrolling through a mobile feed, the screen flickers, and suddenly a smooth, human‑like voice walks them through the product��s features—size, color, material, and even a quick style tip—without them having to read the text. That’s the promise of AI voice for e‑commerce: instant, engaging, and accessible content that can drive conversions and improve SEO (think voice search). It also levels the playing field for users with visual impairments or reading difficulties.

For developers, the challenge isn’t just adding audio to a page; it’s about generating high‑quality, on‑demand voice that sounds natural, brand‑consistent, and can be personalized at scale. That’s where modern text‑to‑speech (TTS) platforms and voice‑cloning technologies come into play.

Text‑to‑Speech 101

At its core, TTS takes a string of text and produces an audio waveform. The pipeline typically involves:

Text Normalization – converting numbers, abbreviations, and special tokens into spoken forms.
Linguistic Analysis – parsing syntax, prosody, and emphasis.
Speech Synthesis – generating phonemes and converting them to audio using a waveform model (e.g., WaveNet, Tacotron).

Voice cloning pushes this further: you can train a model on a small sample of a real person’s voice and produce speech that mimics that voice’s timbre and speaking style. The result is a “synthetic voice” that can be used for brand narrations, product demos, or personalized customer interactions.

Choosing a Platform: Why ElevenLabs

There are several TTS providers out there, but ElevenLabs offers a blend of developer‑friendly APIs, high‑fidelity neural voices, and a straightforward pricing model. With a generous free tier and easy integration, it’s a solid choice for building audio experiences in an e‑commerce stack.

Natural‑sounding voices – their neural models deliver near‑human prosody.
Voice cloning – you can upload a few minutes of audio and get a custom voice in minutes.
Low latency – the API is optimized for real‑time use cases.

If you’re ready to take the next step, sign up at the affiliate link: https://try.elevenlabs.io/kr07zfuqn1bp.

Quick Setup Guide

Below is a minimal example of how to generate a product description audio file using Python. The same logic applies to JavaScript (Node.js) or a simple curl command.

1. Get Your API Key

# After signing up at ElevenLabs, grab your API key from the dashboard
export ELEVENLABS_API_KEY="YOUR_API_KEY_HERE"

2. Python Example

import requests
import json

API_URL = "https://api.elevenlabs.io/v1/text-to-speech/your-voice-id"
HEADERS = {
    "Accept": "audio/mpeg",
    "xi-api-key": os.getenv("ELEVENLABS_API_KEY"),
    "Content-Type": "application/json",
}

payload = {
    "text": "This sleek leather wallet is crafted from premium full‑grain leather, offering 12 card slots and a hidden coin pocket. Its slim profile fits comfortably in any pocket while providing durable protection.",
    "model_id": "eleven_monolingual_v1",
    "voice_settings": {
        "stability": 0.75,
        "similarity_boost": 0.5
    }
}

response = requests.post(API_URL, headers=HEADERS, json=payload)
if response.status_code == 200:
    with open("wallet_description.mp3", "wb") as f:
        f.write(response.content)
    print("Audio file saved.")
else:
    print(f"Error: {response.status_code} – {response.text}")

Tip: Replace your-voice-id with the ID of the voice you want to use. If you want a brand‑specific voice, create a clone first in the ElevenLabs dashboard.

3. Node.js Example

const fetch = require('node-fetch');
const fs = require('fs');

const apiKey = process.env.ELEVENLABS_API_KEY;
const voiceId = 'your-voice-id';
const url = `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`;

const payload = {
  text: "This sleek leather wallet is crafted from premium full‑grain leather, offering 12 card slots and a hidden coin pocket. Its slim profile fits comfortably in any pocket while providing durable protection.",
  model_id: "eleven_monolingual_v1",
  voice_settings: { stability: 0.75, similarity_boost: 0.5 }
};

fetch(url, {
  method: 'POST',
  headers: {
    'Accept': 'audio/mpeg',
    'xi-api-key': apiKey,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(payload)
})
  .then(res => res.arrayBuffer())
  .then(buffer => {
    fs.writeFileSync('wallet_description.mp3', Buffer.from(buffer));
    console.log('Audio file saved.');
  })
  .catch(err => console.error(err));

4. Curl

curl -X POST "https://api.elevenlabs.io/v1/text-to-speech/your-voice-id" \
  -H "Accept: audio/mpeg" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "text": "This sleek leather wallet is crafted from premium full‑grain leather, offering 12 card slots and a hidden coin pocket. Its slim profile fits comfortably in any pocket while providing durable protection.",
        "model_id": "eleven_monolingual_v1",
        "voice_settings": {
          "stability": 0.75,
          "similarity_boost": 0.5
        }
      }' \
  --output wallet_description.mp3

Customizing Voice Cloning

If you want a voice that sounds like your brand’s founder or a local celebrity, you can create a custom voice model:

Collect a clean audio sample – 2–5 minutes of spoken text.
Upload to ElevenLabs – the dashboard offers an easy upload flow.
Wait for training – the model is ready in minutes.
Use the new voice ID – replace your-voice-id in the API calls above.

The cloned voice inherits the emotional tone, pacing, and accent of your source audio, making the narration feel authentic.

Integrating Into Your E‑Commerce Workflow

Generate On‑Demand or Pre‑Generate

On‑Demand: Trigger the TTS API when a visitor opens a product page. This keeps storage costs low but may add a slight latency (usually < 1 s with ElevenLabs).
Pre‑Generate: For high‑traffic items, pre‑generate audio during nightly builds and serve static MP3s via CDN. This guarantees instant playback.

Serving Audio Files

Store in a CDN – upload the MP3s to CloudFront, Akamai, or any edge‑optimized storage.
Add an <audio> element – embed in your product templates:

<audio controls>
  <source src="https://cdn.yoursite.com/audio/wallet_description.mp3" type="audio/mpeg">
  Your browser does not support the audio element.
</audio>

Optional: Use the Web Audio API to add dynamic effects (e.g., volume ramp‑in/out).

Personalization

Combine the TTS API with user data:

Name‑in‑voice: Inject the user’s first name into the script. ElevenLabs supports SSML tags to emphasize or pause around the name.
Dynamic pricing: Generate a short phrase that includes the current price, ensuring the audio stays fresh even as discounts change.

Handling Quality & Performance

Concern	Recommendation
Latency	Use ElevenLabs’ real‑time endpoint; cache responses for recurring product descriptions.
Audio Quality	Stick to `eleven_monolingual_v1` for best naturalness; tweak `stability` and `similarity_boost` for voice personality.
File Size	Keep MP3s under 2 MB for quick loading; ElevenLabs provides bitrate options.
Accessibility	Provide transcripts alongside audio for screen‑reader users.

Pricing & Plans

ElevenLabs offers a free tier that allows up to 5 minutes of audio per day, perfect for prototyping. Paid tiers start at a modest monthly fee and scale with your usage, giving you the flexibility to handle thousands of product descriptions without breaking the bank.

Common Pitfalls & Tips

Over‑fitting the voice: Don’t feed too many short, repetitive sentences into the training data; it can make the voice sound robotic.
Ignoring punctuation: Ensure your text is properly punctuated; TTS engines use punctuation for pauses and intonation.
Not sanitizing user input: If you’re injecting dynamic content (like prices), escape or sanitize to avoid malformed SSML.
Under‑utilizing caching: Re‑generating the same description on every request is wasteful. Cache the MP3s or the base64 data in a Redis store.

Wrap‑Up

Adding AI voice to your product pages is more than a novelty; it’s a tangible way to boost engagement, improve accessibility, and future‑proof your site against the rise of voice search. With a robust TTS platform, a clear workflow, and a few lines of code, you can deliver rich audio experiences that feel natural and on‑brand.

Ready to give your shoppers a voice they’ll love? Sign up with ElevenLabs through the affiliate link and start building today: https://try.elevenlabs.io/kr07zfuqn1bp 🚀

Build a Text-to-Speech App with ElevenLabs and Python

VoiceDeveloper — Sat, 26 Sep 2026 15:31:52 +0000

Why a Python TTS App?

If you’ve ever wanted to turn a paragraph of text into a natural‑sounding voice clip, you’re not alone. Text‑to‑speech (TTS) has moved far beyond the robotic “read‑aloud” voices of the early 2000s. Today, you can generate expressive, human‑like speech in a matter of seconds, and you can even clone a specific voice with a few minutes of audio.

In this post we’ll walk through a complete, production‑ready Python app that talks back to you using ElevenLabs – a service that’s quickly become the go‑to for high‑quality voice AI. By the end you’ll have:

A small Flask server that accepts raw text and returns an MP3 file
A reusable helper that talks to the ElevenLabs API (both via requests and curl)
A quick demo of voice cloning using a custom audio sample

Let’s dive in.

1. Get an ElevenLabs API key

First things first: you need an API key from ElevenLabs. Sign up at the affiliate link below – it’s free to start and gives you a generous quota for testing.

👉 Grab your key here

Once you have the key, store it safely. For local development a .env file works fine:

# .env
ELEVENLABS_API_KEY=your_secret_key_here

We’ll load this with python-dotenv later.

2. Set up the Python environment

Create a fresh virtual environment and install the required packages:

python -m venv venv
source venv/bin/activate   # on Windows: venv\Scripts\activate
pip install flask requests python-dotenv

flask – tiny web framework for our API
requests – simple HTTP client
python-dotenv – loads the .env file into os.environ

3. The core helper: talking to ElevenLabs

ElevenLabs exposes a straightforward REST endpoint. Below is a minimal wrapper that sends text and receives an MP3 stream.

# tts.py
import os
import requests
from typing import Optional

ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
BASE_URL = "https://api.elevenlabs.io/v1"

def synthesize(
    text: str,
    voice_id: str = "EXAVITQu4vr4xnSDxMaL",  # default “Rachel” voice
    model_id: str = "eleven_multilingual_v2",
    stability: float = 0.75,
    similarity_boost: float = 0.85,
) -> bytes:
    """
    Call ElevenLabs TTS endpoint and return raw MP3 bytes.
    """
    url = f"{BASE_URL}/text-to-speech/{voice_id}"
    headers = {
        "xi-api-key": ELEVENLABS_API_KEY,
        "Content-Type": "application/json",
    }
    payload = {
        "text": text,
        "model_id": model_id,
        "voice_settings": {
            "stability": stability,
            "similarity_boost": similarity_boost,
        },
    }

    response = requests.post(url, json=payload, headers=headers, timeout=30)
    response.raise_for_status()
    return response.content

A quick curl equivalent (useful for debugging) looks like this:

curl -X POST "https://api.elevenlabs.io/v1/text-to-speech/EXAVITQu4vr4xnSDxMaL" \
  -H "xi-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
        "text": "Hello, world! This is ElevenLabs speaking.",
        "model_id": "eleven_multilingual_v2",
        "voice_settings": {
          "stability": 0.75,
          "similarity_boost": 0.85
        }
      }' --output hello.mp3

Replace YOUR_API_KEY with the key you got from the link above.

4. Build a tiny Flask wrapper

Now let’s expose the TTS function as a web endpoint. This makes it easy to integrate with front‑ends, mobile apps, or even Discord bots.

# app.py
import os
from flask import Flask, request, send_file, abort
from io import BytesIO
from dotenv import load_dotenv
from tts import synthesize

load_dotenv()  # pulls ELEVENLABS_API_KEY into the environment

app = Flask(__name__)

@app.route("/speak", methods=["POST"])
def speak():
    data = request.get_json()
    if not data or "text" not in data:
        abort(400, description="JSON payload must contain a 'text' field")

    text = data["text"]
    voice_id = data.get("voice_id", "EXAVITQu4vr4xnSDxMaL")

    try:
        audio_bytes = synthesize(text, voice_id=voice_id)
    except Exception as e:
        abort(500, description=str(e))

    # Return as an in‑memory MP3 file
    return send_file(
        BytesIO(audio_bytes),
        mimetype="audio/mpeg",
        as_attachment=False,
        download_name="speech.mp3",
    )

if __name__ == "__main__":
    port = int(os.getenv("PORT", 5000))
    app.run(host="0.0.0.0", port=port, debug=True)

Run it:

python app.py

Then test with curl:

curl -X POST http://localhost:5000/speak \
  -H "Content-Type: application/json" \
  -d '{"text":"ElevenLabs makes voice AI feel magical!"}' \
  --output result.mp3

Open result.mp3 – you should hear a clear, natural voice speaking your sentence.

5. Voice cloning in a few lines

ElevenLabs also lets you clone a custom voice using a short audio sample (as little as 30 seconds). The workflow is:

Upload a WAV/MP3 file to the /voices/add endpoint.
Retrieve the new voice_id.
Use that voice_id in the synthesize call.

Here’s a helper that does the upload:

def add_voice(name: str, audio_path: str) -> str:
    """
    Upload a voice sample and return the new voice_id.
    """
    url = f"{BASE_URL}/voices/add"
    headers = {"xi-api-key": ELEVENLABS_API_KEY}
    files = {
        "files": open(audio_path, "rb"),
        "voice_name": (None, name),
    }

    response = requests.post(url, headers=headers, files=files)
    response.raise_for_status()
    voice_id = response.json()["voice_id"]
    return voice_id

Example usage:

my_voice_id = add_voice("MyDemoVoice", "samples/my_demo.wav")
audio = synthesize("Hello, this is my own voice!", voice_id=my_voice_id)
with open("my_voice.mp3", "wb") as f:
    f.write(audio)

Now you have a personalized voice that sounds like you (or anyone you have permission to clone). This is perfect for building audiobooks, interactive assistants, or even custom IVR systems.

6. Putting it together: a simple front‑end

If you want a quick UI to test the service, add an HTML page that posts to /speak and plays the result:

<!-- static/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>ElevenLabs TTS Demo</title>
</head>
<body>
  <h1>Text‑to‑Speech Playground</h1>
  <textarea id="txt" rows="4" cols="50">Enter text here...</textarea><br>
  <button onclick="speak()">Speak</button>
  <audio id="player" controls></audio>

  <script>
    async function speak() {
      const text = document.getElementById('txt').value;
      const resp = await fetch('/speak', {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({text})
      });
      const blob = await resp.blob();
      const url = URL.createObjectURL(blob);
      document.getElementById('player').src = url;
    }
  </script>
</body>
</html>

Serve the static folder from Flask:

app = Flask(__name__, static_folder="static")
# existing routes stay the same

Now you have a full‑stack demo that you can run locally, deploy to Render, Fly.io, or any container platform, and share with teammates.

7. Tips for Production

Rate limiting – ElevenLabs enforces per‑key limits. Cache generated audio when possible.
Error handling – The API may return 429 (Too Many Requests) or 422 (Invalid voice). Gracefully surface those messages to the client.
Security – Never expose your API key to the browser. All calls to ElevenLabs must happen server‑side.
Audio storage – For longer‑term use, consider uploading MP3s to S3 or another CDN and serving the URL instead of streaming from memory.

8. Next steps

Multi‑language support – ElevenLabs models support dozens of languages; just pass the desired text.
Dynamic voice switching – Pull a list of available voices (/voices) and let users pick.
Streaming – For real‑time chatbots, stream chunks of audio as they become available (requires WebSockets or Server‑Sent Events).

Ready to give it a spin?

All the heavy lifting of realistic speech synthesis and voice cloning is handled by ElevenLabs, letting you focus on the product logic. Grab your free API key, run the code above, and start building the next generation of voice‑first experiences.

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

Happy coding!