Dev.to WebDev 🛠 Dev 👁 0 📖 5 min read

Host Your TTS API Wrapper: Bluehost VPS Setup Guide

Why Build a TTS API Wrapper? Text‑to‑speech (TTS) has moved from a novelty feature to a core part of many modern applications—chatbots, virtual assistants, accessibility tools, and even voice‑cloned content generators.

Why Build a TTS API Wrapper?

Text‑to‑speech (TTS) has moved from a novelty feature to a core part of many modern applications—chatbots, virtual assistants, accessibility tools, and even voice‑cloned content generators. If you’re a developer looking to add lifelike voices to your product, writing a thin wrapper around a commercial TTS engine gives you the flexibility to:

  • Keep your own API key safe (the wrapper can act as a proxy).
  • Cache frequently‑used utterances to cut costs.
  • Add custom preprocessing (e.g., speech‑style tags or language‑model‑based pronunciation).

In this guide we’ll walk through building a lightweight Python Flask wrapper that talks to ElevenLabs’ voice API, then deploy it on a Bluehost VPS. ElevenLabs provides high‑fidelity voices and a generous free tier, while Bluehost offers an affordable, beginner‑friendly VPS that’s easy to set up and scale.

Tip: The code snippets below assume you’re comfortable with the command line and have a basic understanding of Python and Flask.

1. Prerequisites

Item What you need
VPS A Bluehost VPS plan (choose the one that matches your traffic expectations).
Domain Optional, but handy for a real‑world URL.
Python 3.8+ Installed on your VPS.
pip Python package manager.
git For cloning the repo.
ElevenLabs API key Sign up at https://try.elevenlabs.io/kr07zfuqn1bp to get one.

Pro tip: Bluehost’s VPS plans are inexpensive and come with a free SSL certificate—perfect for securing your API.

2. Spin Up a Bluehost VPS

  1. Sign up at https://bluehost.sjv.io/5k0d52.
  2. Pick a plan that fits your expected load (the lowest tier is fine for prototyping).
  3. Choose a data center close to your user base for latency.
  4. Once the VPS is ready, you’ll receive an IP address and SSH credentials.
  5. SSH into the server:
ssh root@<your-vps-ip>
  1. Update the system:
apt update && apt upgrade -y
  1. Install Python 3.8+ and pip:
apt install python3 python3-pip -y
  1. Install virtualenv (optional but recommended):
pip3 install virtualenv

3. Clone the Wrapper Repository

Create a directory for your project and clone a starter repo:

mkdir tts-wrapper
cd tts-wrapper
git clone https://github.com/your-username/tts-wrapper.git .

If you don’t have a repo yet, just create a new folder and start fresh.

4. Set Up a Python Environment

virtualenv venv
source venv/bin/activate
pip install Flask requests

Create a .env file to store your ElevenLabs API key:

echo "ELEVENLABS_API_KEY=YOUR_API_KEY_HERE" > .env

Replace YOUR_API_KEY_HERE with the key you received from ElevenLabs.

5. The Wrapper Code

Here’s a minimal Flask app that forwards requests to ElevenLabs and streams the audio back to the client.

# app.py
import os
import json
import requests
from flask import Flask, request, Response, jsonify
from dotenv import load_dotenv

load_dotenv()
ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
ELEVENLABS_ENDPOINT = "https://api.elevenlabs.io/v1/text-to-speech"

app = Flask(__name__)

@app.route("/speak", methods=["POST"])
def speak():
    data = request.get_json()
    if not data or "text" not in data:
        return jsonify({"error": "Missing 'text' field"}), 400

    text = data["text"]
    voice_id = data.get("voice_id", "eleven_monolingual_v1")  # default voice

    payload = {
        "text": text,
        "voice_settings": {
            "stability": 0.5,
            "similarity_boost": 0.75
        }
    }

    headers = {
        "xi-api-key": ELEVENLABS_API_KEY,
        "Content-Type": "application/json"
    }

    resp = requests.post(
        f"{ELEVENLABS_ENDPOINT}/{voice_id}",
        headers=headers,
        json=payload,
        stream=True
    )

    if resp.status_code != 200:
        return jsonify({"error": "ElevenLabs API error", "details": resp.text}), resp.status_code

    def generate():
        for chunk in resp.iter_content(chunk_size=4096):
            if chunk:
                yield chunk

    return Response(generate(), mimetype="audio/mpeg")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

How it works:

  1. The client POSTs JSON containing text (and optionally a voice_id).
  2. The wrapper calls ElevenLabs’ /text-to-speech/{voice_id} endpoint.
  3. The binary audio stream is forwarded back to the caller without storing it on disk.

6. Run the Wrapper Locally

export FLASK_APP=app.py
flask run --host=0.0.0.0 --port=8000

You can test it with curl:

curl -X POST http://<your-vps-ip>:8000/speak \
     -H "Content-Type: application/json" \
     -d '{"text":"Hello, world!", "voice_id":"eleven_monolingual_v1"}' \
     --output hello.mp3

The hello.mp3 file should play a natural‑sounding voice.

7. Deploy to Production

7.1 Install a Production WSGI Server

Gunicorn is a popular choice for serving Flask apps.

pip install gunicorn

7.2 Create a Systemd Service

sudo nano /etc/systemd/system/tts-wrapper.service

Add the following (replace /home/root/tts-wrapper with your path):

[Unit]
Description=ElevenLabs TTS Wrapper
After=network.target

[Service]
User=root
WorkingDirectory=/home/root/tts-wrapper
Environment="PATH=/home/root/tts-wrapper/venv/bin"
ExecStart=/home/root/tts-wrapper/venv/bin/gunicorn --workers 3 --bind 0.0.0.0:8000 app:app
Restart=on-failure

[Install]
WantedBy=multi-user.target

Enable and start the service:

systemctl daemon-reload
systemctl enable tts-wrapper
systemctl start tts-wrapper

Verify it’s running:

systemctl status tts-wrapper

7.3 Secure the Endpoint

If you have a domain, point it to your VPS IP and obtain an SSL certificate via Let’s Encrypt:

apt install certbot python3-certbot-nginx -y
certbot --nginx -d yourdomain.com

Then configure Nginx as a reverse proxy to Gunicorn, ensuring HTTPS is enforced.

8. Scaling and Caching

For high‑traffic scenarios:

  • Cache the audio files in Redis or a simple file cache keyed by a hash of the request payload.
  • Use a CDN to serve static audio assets.
  • Upgrade the VPS plan on Bluehost when needed—Bluehost’s VPS tiers let you add RAM or CPU with a single click.

9. Final Thoughts

You now have a lightweight, production‑ready TTS API wrapper that leverages ElevenLabs’ cutting‑edge voices. By hosting it on a Bluehost VPS, you get:

  • Affordable pricing with a free SSL certificate.
  • Straightforward SSH access and one‑click app deployment.
  • The flexibility to scale up when your user base grows.

The combination of ElevenLabs and Bluehost gives you a powerful, cost‑effective stack for any voice‑AI project—from prototype to production.

Call to Action

Ready to give your application a natural voice? Sign up for ElevenLabs at https://try.elevenlabs.io/kr07zfuqn1bp to unlock high‑quality TTS. Then, get a Bluehost VPS at https://bluehost.sjv.io/5k0d52 and deploy your wrapper today. Happy coding!

📰 Read the original article on Dev.to WebDev

Originally published by Dev.to WebDev. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.