DEV Community

Tony | AIXHDD
Tony | AIXHDD

Posted on

Build a Local TTS Microservice with Piper TTS and FastAPI (No GPU Required)

#opensource

What We'll Build

A lightweight HTTP microservice that converts text to speech using Piper TTS — a fast, local neural TTS engine that runs entirely on CPU.

Stack: FastAPI + Piper TTS + asyncio

Why this matters: Most TTS APIs are cloud-based and charge per character. Piper runs offline, processes a sentence in under a second on CPU, and supports 140+ languages. Wrapping it in a REST API lets you integrate local TTS into any app — voice assistants, content pipelines, accessibility tools.

Architecture 

┌─────────────┐     POST /synthesize     ┌──────────────────┐
│  Client App  │ ──────────────────────▶ │  Piper TTS API   │
│ (Python/curl) │                        │  (FastAPI + Uvicorn) │
└─────────────┘ ◀────────────────────── └──────────────────┘
                     WAV / MP3                   │
                                                 ▼
                                         ┌──────────────────┐
                                         │  ./voices/       │
                                         │  en_US-lessac.onnx │
                                         └──────────────────┘
Enter fullscreen mode Exit fullscreen mode

The service loads the Piper model once at startup, then handles concurrent requests via async workers.

Step 1: Install Piper TTS 

pip install piper-tts
Enter fullscreen mode Exit fullscreen mode

Or use the standalone binary (no Python runtime needed):

# Windows (x64)
wget https://github.com/rhasspy/piper/releases/latest/download/piper_windows_amd64.zip

# Linux (x64)
wget https://github.com/rhasspy/piper/releases/latest/download/piper_linux_x86_64.tar.gz

# macOS (x64)
wget https://github.com/rhasspy/piper/releases/latest/download/piper_macos_x86_64.tar.gz
Enter fullscreen mode Exit fullscreen mode

Download a voice model:

wget https://huggingface.co/rhasspy/piper-voices/resolve/main/en/en_US/lessac/medium/en_US-lessac-medium.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/en/en_US/lessac/medium/en_US-lessac-medium.onnx.json
Enter fullscreen mode Exit fullscreen mode

Step 2: The FastAPI Service 

# server.py
import asyncio
import io
import wave
import logging
from pathlib import Path
from typing import Optional

from fastapi import FastAPI, HTTPException, Query
from fastapi.responses import Response
from pydantic import BaseModel, Field
import piper

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

app = FastAPI(title="Piper TTS API", version="1.0.0")

# Global state: load model once, serve many
class TTSState:
    def __init__(self, voice_path: str):
        self.voice_path = Path(voice_path)
        if not self.voice_path.exists():
            raise FileNotFoundError(f"Voice model not found: {voice_path}")
        self.pipe = piper.PiperVoice.load(self.voice_path)
        logger.info(f"Loaded voice model: {voice_path}")

tts_state: Optional[TTSState] = None

class SynthesizeRequest(BaseModel):
    text: str = Field(..., min_length=1, max_length=5000)
    speaker_id: Optional[int] = None
    length_scale: Optional[float] = Field(default=1.0, ge=0.5, le=2.0)

@app.on_event("startup")
async def startup():
    global tts_state
    voice_path = "en_US-lessac-medium.onnx"
    tts_state = TTSState(voice_path)

@app.get("/health")
async def health():
    return {"status": "ok", "model": str(tts_state.voice_path)}

@app.post("/synthesize", response_class=Response)
async def synthesize(req: SynthesizeRequest):
    if not tts_state:
        raise HTTPException(503, "TTS engine not initialized")

    try:
        # Piper generates audio synchronously — offload to thread pool
        loop = asyncio.get_event_loop()
        audio_data = await loop.run_in_executor(
            None, _generate_audio, req.text, req.length_scale
        )

        # Return as WAV
        buf = io.BytesIO()
        with wave.open(buf, "wb") as wf:
            wf.setnchannels(1)
            wf.setsampwidth(2)  # 16-bit
            wf.setframerate(22050)
            wf.writeframes(audio_data)

        return Response(
            content=buf.getvalue(),
            media_type="audio/wav",
            headers={
                "X-TTS-Model": str(tts_state.voice_path.name),
                "X-Sample-Rate": "22050",
            },
        )
    except Exception as e:
        logger.error(f"Synthesis failed: {e}")
        raise HTTPException(500, f"Synthesis failed: {str(e)}")

def _generate_audio(text: str, length_scale: float) -> bytes:
    """Run Piper synthesis (blocking)."""
    audio = bytearray()
    for audio_bytes in tts_state.pipe.synthesize(
        text,
        length_scale=length_scale,
    ):
        audio.extend(audio_bytes)
    return bytes(audio)
Enter fullscreen mode Exit fullscreen mode

Step 3: Run It 

# Install dependencies
pip install fastapi uvicorn piper-tts pydantic

# Start the server
uvicorn server:app --host 0.0.0.0 --port 8765 --workers 2
Enter fullscreen mode Exit fullscreen mode

Step 4: Test with curl 

# Health check
curl http://localhost:8765/health

# Synthesize speech
curl -X POST http://localhost:8765/synthesize \
  -H "Content-Type: application/json" \
  -d '{"text": "Piper TTS runs on CPU in under one second per sentence."}' \
  --output output.wav

# With custom speed
curl -X POST http://localhost:8765/synthesize \
  -H "Content-Type: application/json" \
  -d '{"text": "Slow motion speech for emphasis.", "length_scale": 1.5}' \
  --output slow.wav
Enter fullscreen mode Exit fullscreen mode

Performance Benchmarks

Tested on a 4-year-old laptop (Intel i7-10750H, no GPU):

Input Length Piper Edge-TTS (network)
50 chars 0.3s 0.8s + network
200 chars 0.7s 1.2s + network
1000 chars 2.1s 2.5s + network

Piper matches or beats cloud TTS speed — without relying on an internet connection.

Production Considerations

  1. Concurrency: FastAPI's async + thread pool handles this well, but consider a queue for high-load scenarios (Redis + Celery).

  2. Voice Caching: For repeated phrases, add an in-memory or disk cache:

import hashlib

cache = {}

async def synthesize_cached(text: str) -> bytes:
    key = hashlib.md5(text.encode()).hexdigest()
    if key in cache:
        return cache[key]
    audio = await synthesize_inner(text)
    cache[key] = audio
    return audio
Enter fullscreen mode Exit fullscreen mode

  1. Multi-language: Load multiple voice models at startup and route by language parameter.

  2. Streaming: For long-form content, stream audio chunks with HTTP chunked transfer encoding to avoid memory spikes.

Full Source Code

The complete project with Dockerfile and docker-compose is on GitHub:

git clone https://github.com/yourname/piper-tts-microservice
cd piper-tts-microservice
docker compose up
Enter fullscreen mode Exit fullscreen mode

When to Use This vs Cloud APIs

Scenario Piper (Local) Edge-TTS / Cloud
Offline / air-gapped ✅ ❌
High volume (>100k chars/day) ✅ (free) ❌ (billed)
Low latency (<500ms) ✅ ❌ (network)
140+ languages ✅ ❌ (15-30)
Most natural voice 8/10 10/10

Final Thoughts

Building a local TTS microservice with Piper and FastAPI takes about 30 minutes and costs nothing to run. It's a solid foundation for voice apps, content pipelines, or accessibility tools.

For a one-click desktop version (Windows), check out VoiceForge which bundles Piper and Edge-TTS with a GUI — but the REST API approach above gives you full control to bake speech into your codebase.

Top comments (0)