AI Voice Tools — ElevenLabs, Google TTS, and Amazon Polly API Guide for 2026

pip install elevenlabs

from elevenlabs.client import ElevenLabs
from elevenlabs import save
 
client = ElevenLabs(api_key="xi-api-...")
 
def text_to_speech(
    text: str,
    voice_id: str = "21m00Tcm4TlvDq8ikWAM",  # Rachel (default)
    output_path: str = "output.mp3"
) -> None:
    audio = client.text_to_speech.convert(
        text=text,
        voice_id=voice_id,
        model_id="eleven_multilingual_v2",
        voice_settings={
            "stability": 0.5,        # 0-1: lower = more expressive
            "similarity_boost": 0.8, # 0-1: adherence to voice
            "style": 0.0,            # 0-1: style exaggeration
            "use_speaker_boost": True
        }
    )
    save(audio, output_path)
 
text_to_speech(
    "The deployment completed successfully. All health checks passed.",
    output_path="deployment_update.mp3"
)

def stream_speech(text: str, voice_id: str) -> bytes:
    """Stream audio chunks for low-latency playback."""
    audio_stream = client.text_to_speech.stream(
        text=text,
        voice_id=voice_id,
        model_id="eleven_turbo_v2_5"  # Fastest model, good quality
    )
    
    chunks = []
    for chunk in audio_stream:
        if chunk:
            chunks.append(chunk)
    return b"".join(chunks)

from google.cloud import texttospeech
 
def google_tts(
    text: str,
    language_code: str = "en-US",
    voice_name: str = "en-US-Neural2-D",  # Male voice
    output_path: str = "output.mp3"
) -> None:
    client = texttospeech.TextToSpeechClient()
    
    synthesis_input = texttospeech.SynthesisInput(text=text)
    
    voice = texttospeech.VoiceSelectionParams(
        language_code=language_code,
        name=voice_name,
    )
    
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3,
        speaking_rate=1.0,   # 0.25-4.0x
        pitch=0.0,           # -20 to +20 semitones
        volume_gain_db=0.0   # -96 to +16 dB
    )
    
    response = client.synthesize_speech(
        input=synthesis_input,
        voice=voice,
        audio_config=audio_config
    )
    
    with open(output_path, "wb") as f:
        f.write(response.audio_content)

ssml_text = """
<speak>
  Welcome back.
  <break time="500ms"/>
  You have <emphasis level="strong">3 pending items</emphasis>
  that need your attention.
  <prosody rate="slow" pitch="+2st">Please review them now.</prosody>
</speak>
"""
 
synthesis_input = texttospeech.SynthesisInput(ssml=ssml_text)

import boto3
import io
from contextlib import closing
 
polly = boto3.client("polly", region_name="us-east-1")
 
def polly_tts(text: str, voice_id: str = "Joanna") -> bytes:
    """Generate audio and return as bytes."""
    response = polly.synthesize_speech(
        Text=text,
        OutputFormat="mp3",
        VoiceId=voice_id,
        Engine="neural",     # Use neural engine for best quality
        LanguageCode="en-US"
    )
    
    with closing(response["AudioStream"]) as stream:
        return stream.read()
 
def polly_long_form(text: str, bucket: str, key: str) -> str:
    """For texts over 3000 characters, use async S3 output."""
    response = polly.start_speech_synthesis_task(
        Text=text,
        OutputFormat="mp3",
        VoiceId="Joanna",
        Engine="neural",
        OutputS3BucketName=bucket,
        OutputS3KeyPrefix=key
    )
    task_id = response["SynthesisTask"]["TaskId"]
    return task_id  # Poll for completion

import hashlib
import redis
 
cache = redis.Redis()
 
def cached_tts(text: str, voice_id: str) -> bytes:
    cache_key = hashlib.sha256(f"{text}:{voice_id}".encode()).hexdigest()
    
    cached = cache.get(cache_key)
    if cached:
        return cached
    
    audio = stream_speech(text, voice_id)
    cache.set(cache_key, audio, ex=86400 * 7)  # 7-day TTL
    return audio