Host Your TTS API Wrapper: Bluehost VPS Setup Guide

Why a Dedicated TTS API Wrapper Matters

If you’ve been tinkering with voice AI, you’ve probably hit the same roadblock: calling a cloud TTS service from your app feels clunky, and every new feature or language change means you’re rewriting a handful of lines. A lightweight wrapper keeps the heavy lifting in one place, makes your code cleaner, and lets you swap providers without touching the rest of your stack.

In this guide we’ll walk through building a minimal, production‑ready wrapper for ElevenLabs’ text‑to‑speech API and then show you how to spin up a VPS on Bluehost, install everything you need, and get the wrapper running in minutes. The whole process is budget‑friendly and perfect for solo developers or small teams who want to keep their focus on building voice experiences, not managing infrastructure.

---

Meet ElevenLabs

ElevenLabs is one of the most advanced TTS engines out there right now. It offers:

• High‑quality neural voices that sound natural and expressive.
• Voice cloning so you can create a custom voice from a few minutes of audio.
• Real‑time streaming for low‑latency applications.

You can sign up for a free tier and get started right away. If you want to dive deeper into their API, check out the official docs or try the library examples below.

👉 Get ElevenLabs today: https://try.elevenlabs.io/kr07zfuqn1bp

---

Step 1 – Spin Up a VPS on Bluehost

Bluehost offers reliable VPS hosting with SSD storage, hourly billing, and a straightforward control panel. For a TTS wrapper you’ll only need a few GB of RAM and a modest CPU, so the cheapest plan is more than enough.

1. Create an account: https://bluehost.sjv.io/5k0d52
2. Choose a VPS plan – the “Standard” plan (1 GB RAM, 1 vCPU) is a great starting point.
3. Pick a location – a data center close to your user base reduces latency.
4. Set up your server – Bluehost’s one‑click installer will give you a clean Ubuntu 22.04 LTS box.

Once the VPS is running, SSH into it:

ssh root@your-vps-ip

You’re now ready to install Python and the ElevenLabs client.

---

Step 2 – Install Dependencies

# Update and upgrade
sudo apt-get update && sudo apt-get upgrade -y

# Install Python 3.11 and pip
sudo apt-get install -y python3.11 python3-pip

# Optional: create a virtual environment
python3 -m venv tts-venv
source tts-venv/bin/activate

# Install the ElevenLabs Python SDK
pip install elevenlabs

If you prefer to keep everything in a container, you can build a lightweight Docker image later. For now, a virtual environment keeps the wrapper isolated from the system packages.

---

Step 3 – Build the Wrapper

Here’s a tiny, reusable wrapper that abstracts away authentication, error handling, and basic caching. Feel free to extend it with additional features like voice cloning or streaming.

# tts_wrapper.py
import os
import time
import requests
from pathlib import Path
from elevenlabs import ElevenLabs

ELEVENLABS_API_KEY = os.getenv("ELEVENLABS_API_KEY")
if not ELEVENLABS_API_KEY:
    raise RuntimeError("ELEVENLABS_API_KEY env var not set")

client = ElevenLabs(api_key=ELEVENLABS_API_KEY)

# Simple in‑memory cache
CACHE = {}
CACHE_TTL = 3600  # seconds

def synthesize(text: str, voice_id: str = "en-US-Wavenet-D") -> bytes:
    """
    Return audio bytes for the given text and voice.
    """
    cache_key = f"{voice_id}:{text}"
    cached = CACHE.get(cache_key)
    if cached and time.time() - cached["timestamp"] < CACHE_TTL:
        return cached["audio"]

    print(f"Synthesizing: {text[:30]}…")
    audio = client.text_to_speech(text, voice=voice_id)
    CACHE[cache_key] = {"audio": audio, "timestamp": time.time()}
    return audio

if __name__ == "__main__":
    # Demo usage
    output_file = Path("output.wav")
    audio_bytes = synthesize("Hello, world! This is a test from ElevenLabs.")
    output_file.write_bytes(audio_bytes)
    print(f"Saved to {output_file}")

How to Run

export ELEVENLABS_API_KEY=your_api_key_here
python tts_wrapper.py

You should see a output.wav file in your directory. Play it to confirm the voice sounds right.

---

Step 4 – Expose the Wrapper as a REST API

For most projects you’ll want to expose the wrapper behind an HTTP endpoint so your frontend or microservice can call it. Flask is a minimal choice that gets the job done quickly.

pip install flask

Create app.py:

# app.py
from flask import Flask, request, send_file, jsonify
import io
from tts_wrapper import synthesize

app = Flask(__name__)

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

    text = data["text"]
    voice = data.get("voice", "en-US-Wavenet-D")

    audio_bytes = synthesize(text, voice)
    return send_file(
        io.BytesIO(audio_bytes),
        mimetype="audio/wav",
        as_attachment=False,
        download_name="speech.wav",
    )

if __name__ == "__main__":
    # Run in debug mode for dev; in prod use gunicorn
    app.run(host="0.0.0.0", port=5000, debug=True)

Run it:

python app.py

You can test the endpoint with curl:

curl -X POST -H "Content-Type: application/json" \
     -d '{"text":"Testing ElevenLabs API"}' \
     http://localhost:5000/speak --output test.wav

Open test.wav and you’ll hear the synthesized speech.

---

Step 5 – Deploy Behind a Reverse Proxy (Optional)

If you want a production‑ready setup, add Nginx as a reverse proxy. It also lets you serve static files and enforce HTTPS with Let’s Encrypt.

sudo apt-get install -y nginx
sudo ufw allow 'Nginx Full'

Create /etc/nginx/sites-available/tts:

server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Enable the site and reload Nginx:

sudo ln -s /etc/nginx/sites-available/tts /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Now you can access http://your-domain.com/speak from anywhere.

---

Step 6 – Scale and Monitor

For a single user or low‑traffic project, the Flask dev server is fine. For higher loads:

• Gunicorn + Supervisor: run multiple workers.
• Docker: containerize the app and use Docker Compose.
• CloudWatch or Prometheus: collect metrics.
• Bluehost Managed Security: enable the built‑in firewall and auto‑updates.

Bluehost’s VPS gives you the flexibility to add a load balancer or a Redis cache later if you hit performance bottlenecks.

---

Troubleshooting Tips

Issue	Fix
ELEVENLABS_API_KEY not found	Export the key in your shell or add it to /etc/environment
Request timeouts	Increase ElevenLabs timeout in the SDK or add a retry loop
Audio not playing	Verify MIME type (audio/wav) and check the file size
High CPU usage	Use a more efficient caching strategy or limit concurrent workers

---

Wrap‑Up

You now have a fully functional TTS wrapper powered by ElevenLabs, running on a lightweight Bluehost VPS. This setup is:

• Cost‑effective – the cheapest Bluehost VPS is under $10/month.
• Fast to deploy – one‑click Ubuntu install, a few terminal commands.
• Scalable – add workers, containers, or a CDN as traffic grows.

Feel free to fork the code, add voice cloning, or integrate it into your existing chatbot framework.

---

Call to Action

Ready to turn text into crystal‑clear speech? Sign up for ElevenLabs and start building today: https://try.elevenlabs.io/kr07zfuqn1bp

Want a hassle‑free VPS to host your voice AI stack? Get a Bluehost VPS now: https://bluehost.sjv.io/5k0d52

Happy coding, and may your voices always sound amazing!