Text to Speech API

API Reference: POST /audio/speech

Provider capabilities

The table below summarizes gateway support for this endpoint by provider.

Legend:

✅ Supported by Provider and Truefoundry
Provided by provider, but not by Truefoundry
Provider does not support this feature

Provider	Text To Speech
OpenAI	✅
Azure OpenAI	✅
Azure AI Foundry	✅
Anthropic
Bedrock
Vertex	✅
Cohere
Gemini	✅
Groq	✅
Together-AI
xAI
DeepInfra
DeepGram	✅
Cartesia	✅
ElevenLabs	✅
Resemble AI	✅
Smallest AI	✅

For every gateway endpoint and provider, see Supported APIs. Text to speech (TTS) turns written text into audio. The gateway supports two ways to call it:

Approach	Use for	Base path
OpenAI-compatible API	OpenAI, Azure OpenAI, Azure AI Foundry, Groq	`{GATEWAY_BASE_URL}`
Native SDK / HTTP	Deepgram, Cartesia, ElevenLabs, Gemini, Vertex, Smallest AI	`{GATEWAY_BASE_URL}/tts/{providerAccountName}`

Add models to the gateway

Before you can call the Text to Speech API, add your TTS models to TrueFoundry through a provider account. When adding a model, select Text to Speech as the model type.

You can also call TTS through a virtual model to load-balance or fail over across multiple TTS providers. Create a virtual model with the Text to Speech model type and use its name as model in your request.

Provider	Setup guide
OpenAI	OpenAI
Azure OpenAI	Azure OpenAI
Azure AI Foundry	Azure AI Foundry
Groq	Groq
Deepgram	Deepgram
Cartesia	Cartesia
ElevenLabs	ElevenLabs
Resemble AI	Resemble AI
Gemini	Google Gemini
Vertex	Google Vertex
Smallest AI	Smallest AI

Code snippets

Before you start: Replace {GATEWAY_BASE_URL} with your gateway base URL and your-tfy-api-key with your TrueFoundry API key. For the native SDK, replace {providerAccountName} with the display name of your provider account on TrueFoundry.

Model names: For audio (STT/TTS), the model ID in code must match the display name of the model on your TrueFoundry provider account.

Which SDK to use: For OpenAI, Azure OpenAI, Azure AI Foundry, and Groq, use the OpenAI SDK (same API). For Deepgram, Cartesia, ElevenLabs, Gemini, and Vertex, use each provider’s native SDK with the gateway URL above. For Smallest AI, call the Waves HTTP API directly.

from pathlib import Path
from openai import OpenAI

BASE_URL = "{GATEWAY_BASE_URL}"
API_KEY = "your-tfy-api-key"

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

output_path = Path(__file__).parent / "output.mp3"
with client.audio.speech.with_streaming_response.create(
    model="openai-main/gpt-4o-mini-tts",  # truefoundry model name
    voice="alloy",
    input="Hello, how are you?",
) as response:
    response.stream_to_file(output_path)

print(output_path)

from pathlib import Path
from openai import OpenAI

BASE_URL = "{GATEWAY_BASE_URL}"
API_KEY = "your-tfy-api-key"

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

output_path = Path(__file__).parent / "output.mp3"
with client.audio.speech.with_streaming_response.create(
    model="azure-openai-main/your-tts-deployment",  # truefoundry model name
    voice="alloy",
    input="Hello, how are you?",
) as response:
    response.stream_to_file(output_path)

print(output_path)

from pathlib import Path
from openai import OpenAI

BASE_URL = "{GATEWAY_BASE_URL}"
API_KEY = "your-tfy-api-key"

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

output_path = Path(__file__).parent / "output.mp3"
with client.audio.speech.with_streaming_response.create(
    model="azure-foundry-main/your-tts-deployment",  # truefoundry model name
    voice="alloy",
    input="Hello, how are you?",
) as response:
    response.stream_to_file(output_path)

print(output_path)

from pathlib import Path
from openai import OpenAI

BASE_URL = "{GATEWAY_BASE_URL}"
API_KEY = "your-tfy-api-key"

client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

output_path = Path(__file__).parent / "output.mp3"
with client.audio.speech.with_streaming_response.create(
    model="groq-main/your-tts-model",  # truefoundry model name
    voice="alloy",
    input="Hello, how are you?",
) as response:
    response.stream_to_file(output_path)

print(output_path)

from deepgram import DeepgramClient
from deepgram.environment import DeepgramClientEnvironment

TFY_API_KEY = "your-tfy-api-key"
OUTPUT_FILE = "/path/to/output.mp3"

env = DeepgramClientEnvironment(
    base="{GATEWAY_BASE_URL}/tts/{deepgramProviderAccountName}",
    production="",
    agent="",
)
client = DeepgramClient(
	api_key="dummy",
	environment=env,
	headers={"x-tfy-api-key": TFY_API_KEY},
)

response = client.speak.v1.audio.generate(
    text="Hello! This is a test of Deepgram text to speech via the gateway.",
    model="aura-2-thalia-en",  # actual model id
)

with open(OUTPUT_FILE, "wb") as f:
    for chunk in response:
        f.write(chunk)

print(OUTPUT_FILE)

import asyncio
import httpx
from cartesia import AsyncCartesia

TFY_API_KEY = "your-tfy-api-key"
BASE_URL = "{GATEWAY_BASE_URL}/tts/{cartesiaProviderAccountName}"
OUTPUT_FILE = "/path/to/output.wav"

client = AsyncCartesia(
    api_key="dummy",
    base_url=BASE_URL,
    http_client=httpx.AsyncClient(
        headers={"x-tfy-api-key": TFY_API_KEY},
    ),
)


async def main():
    response = await client.tts.generate(
        model_id="sonic-3.5",  # actual model id
        transcript="Welcome to Cartesia Sonic!",
        voice={"mode": "id", "id": "a0e99841-438c-4a64-b679-ae501e7d6091"},
        language="en",
        output_format={
            "container": "wav",
            "sample_rate": 44100,
            "encoding": "pcm_s16le",
        },
    )
    with open(OUTPUT_FILE, "wb") as f:
        f.write(await response.read())
    print(OUTPUT_FILE)


asyncio.run(main())

import httpx
from elevenlabs import ElevenLabs

BASE_URL = "{GATEWAY_BASE_URL}/tts/{elevenLabsProviderAccountName}"
TFY_API_KEY = "your-tfy-api-key"
OUTPUT_FILE = "/path/to/output.mp3"

client = ElevenLabs(
    api_key="dummy",
    base_url=BASE_URL,
    httpx_client=httpx.Client(
        headers={"x-tfy-api-key": TFY_API_KEY},
    ),
)

response = client.text_to_speech.convert(
    voice_id="JBFqnCBsd6RMkjVDRZzb",
    output_format="mp3_44100_128",
    text="The first move is what sets everything in motion.",
    model_id="eleven_v3",  # actual model id
)

with open(OUTPUT_FILE, "wb") as f:
    for chunk in response:
        f.write(chunk)

print(OUTPUT_FILE)

import wave
from google import genai
from google.genai import types

def save_wav(filename, pcm, channels=1, rate=24000, sample_width=2):
    with wave.open(filename, "wb") as wf:
        wf.setnchannels(channels)
        wf.setsampwidth(sample_width)
        wf.setframerate(rate)
        wf.writeframes(pcm)

TFY_API_KEY = "your-tfy-api-key"
BASE_URL = "{GATEWAY_BASE_URL}/tts/{geminiProviderAccountName}"

client = genai.Client(
    api_key="dummy",
    http_options=types.HttpOptions(
        base_url=BASE_URL,
        headers={"x-tfy-api-key": TFY_API_KEY},
    ),
)

response = client.models.generate_content(
    model="gemini-2.5-flash-preview-tts",  # actual model id
    contents="Say cheerfully: Have a wonderful day!",
    config=types.GenerateContentConfig(
        response_modalities=["AUDIO"],
        speech_config=types.SpeechConfig(
            voice_config=types.VoiceConfig(
                prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name="Kore"),
            )
        ),
    ),
)

audio_data = response.candidates[0].content.parts[0].inline_data.data
save_wav("output.wav", audio_data)
print("output.wav")

from google.cloud import texttospeech
from google.api_core.client_options import ClientOptions
from google.auth.credentials import AnonymousCredentials

TFY_API_KEY = "your-tfy-api-key"
BASE_URL = "{GATEWAY_BASE_URL}/tts/{vertexProviderAccountName}"
MODEL_NAME = "vertex-main/chirp"  # truefoundry model name 

client_options = ClientOptions(api_endpoint=BASE_URL)
client = texttospeech.TextToSpeechClient(
    transport="rest",
    client_options=client_options,
    credentials=AnonymousCredentials(),
)
client._transport._session.headers.update({
    "x-tfy-api-key": TFY_API_KEY,
    "x-tfy-model-name": MODEL_NAME,
})

response = client.synthesize_speech(
    input=texttospeech.SynthesisInput(text="Hello, how are you doing?"),
    voice=texttospeech.VoiceSelectionParams(
        language_code="en-US",
        name="en-US-Wavenet-D",
    ),
    audio_config=texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3,
    ),
)

with open("output.mp3", "wb") as f:
    f.write(response.audio_content)

print("output.mp3")

import requests

TFY_API_KEY = "your-tfy-api-key"
BASE_URL = "{GATEWAY_BASE_URL}/tts/{smallestAiProviderAccountName}"

response = requests.post(
    f"{BASE_URL}/waves/v1/smallest-tts/get_speech",
    headers={
        "Authorization": f"Bearer {TFY_API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "text": "Modern problems require modern solutions.",
        "voice_id": "magnus",
        "sample_rate": 24000,
        "speed": 1.0,
        "language": "en",
        "output_format": "wav",
    },
)

with open("output.wav", "wb") as f:
    f.write(response.content)

print(f"Saved output.wav ({len(response.content):,} bytes)")

Response

TTS responses are audio bytes. Each snippet above writes the audio to a file and prints the output path.

Get Started

LLM Gateway

MCP Registry and Gateway

Skills Registry

Prompt Registry

Guardrails and Security

Observability

Deployment

Admin Guide

Chat

Messages

Embeddings

Rerank

Responses

Image

Audio

Batch

Files

Fine-tuning

Moderations

Models

Provider capabilities

Add models to the gateway

Code snippets

Response

​Provider capabilities

​Add models to the gateway

​Code snippets

​Response

Provider capabilities

Add models to the gateway

Code snippets

Response