How to Add Text-to-Speech to a Python App with Inworld AI

import requests, base64

response = requests.post(
    "https://api.inworld.ai/tts/v1/voice",
    headers={"Authorization": f"Basic {API_KEY}"},
    json={"voiceId": "Sarah", "modelId": "inworld-tts-1.5-max", "text": "Hello world"}
)
audio = base64.b64decode(response.json()["audioContent"])
with open("output.mp3", "wb") as f:
    f.write(audio)

import requests
import base64

# pip install requests
API_KEY = "your_api_key_here"  # From https://platform.inworld.ai

session = requests.Session()

response = session.post(
    "https://api.inworld.ai/tts/v1/voice",
    headers={
        "Authorization": f"Basic {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "voiceId": "Sarah",
        "modelId": "inworld-tts-1.5-max",
        "text": "Welcome to our application. This audio was generated with the Inworld TTS API."
    },
    timeout=30
)
response.raise_for_status()

result = response.json()
audio_bytes = base64.b64decode(result["audioContent"])

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

print(f"Saved {len(audio_bytes)} bytes to output.mp3")

import requests

API_KEY = "your_api_key_here"

response = requests.get(
    "https://api.inworld.ai/voices/v1/voices",
    headers={"Authorization": f"Basic {API_KEY}"}
)

voices = response.json()["voices"]
print(f"Available voices: {len(voices)}")
for voice in voices[:10]:
    print(f"  {voice['voiceId']}: {voice['displayName']}")

import requests
import base64
import json

API_KEY = "your_api_key_here"

session = requests.Session()

text = """This is a longer passage that benefits from streaming.
The API returns audio chunks as they are generated,
so playback can start before the full synthesis is complete."""

response = session.post(
    "https://api.inworld.ai/tts/v1/voice:stream",
    headers={
        "Authorization": f"Basic {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "voiceId": "Sarah",
        "modelId": "inworld-tts-1.5-max",
        "text": text
    },
    stream=True,
    timeout=30
)
response.raise_for_status()

audio_chunks = []
for line in response.iter_lines():
    if line:
        data = json.loads(line)
        chunk = base64.b64decode(data["result"]["audioContent"])
        audio_chunks.append(chunk)

audio = b"".join(audio_chunks)
with open("streamed_output.mp3", "wb") as f:
    f.write(audio)

print(f"Received {len(audio_chunks)} chunks, {len(audio)} bytes total")

import requests
import base64
import json
import pyaudio

API_KEY = "your_api_key_here"

session = requests.Session()

response = session.post(
    "https://api.inworld.ai/tts/v1/voice:stream",
    headers={
        "Authorization": f"Basic {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "voiceId": "Sarah",
        "modelId": "inworld-tts-1.5-max",
        "text": "Streaming audio plays back in realtime as chunks arrive.",
        "audioConfig": {
            "audioEncoding": "LINEAR16",
            "sampleRateHertz": 24000
        }
    },
    stream=True
)

# Play each chunk as it arrives
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=24000, output=True)

for line in response.iter_lines():
    if line:
        data = json.loads(line)
        chunk = base64.b64decode(data["result"]["audioContent"])
        stream.write(chunk)

stream.stop_stream()
stream.close()
p.terminate()

import requests
import base64

API_KEY = "your_api_key_here"

session = requests.Session()

# Step 1: Clone a voice from an audio sample (5-15 seconds, wav/mp3/webm, max 4MB)
with open("voice_sample.wav", "rb") as f:
    audio_data = base64.b64encode(f.read()).decode()

clone_response = session.post(
    "https://api.inworld.ai/voices/v1/voices:clone",
    headers={
        "Authorization": f"Basic {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "displayName": "my-custom-voice",
        "langCode": "EN_US",
        "voiceSamples": [{"audioData": audio_data}]
    },
    timeout=60
)
clone_response.raise_for_status()

cloned_voice = clone_response.json()
custom_voice_id = cloned_voice["voice"]["voiceId"]
print(f"Cloned voice ID: {custom_voice_id}")

# Step 2: Use the cloned voice for TTS
tts_response = session.post(
    "https://api.inworld.ai/tts/v1/voice",
    headers={
        "Authorization": f"Basic {API_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "voiceId": custom_voice_id,
        "modelId": "inworld-tts-1.5-max",
        "text": "This speech uses my cloned voice."
    }
)

audio = base64.b64decode(tts_response.json()["audioContent"])
with open("cloned_voice_output.mp3", "wb") as f:
    f.write(audio)

import requests
import base64
import json

API_KEY = "your_api_key_here"

session = requests.Session()
headers = {
    "Authorization": f"Basic {API_KEY}",
    "Content-Type": "application/json"
}

# Step 1: Transcribe audio with Inworld STT
with open("user_audio.wav", "rb") as f:
    audio_input = base64.b64encode(f.read()).decode()

stt_response = session.post(
    "https://api.inworld.ai/stt/v1/transcribe",
    headers=headers,
    json={
        "transcribeConfig": {
            "modelId": "groq/whisper-large-v3",
            "audioEncoding": "AUTO_DETECT",
            "language": "en-US"
        },
        "audioData": {
            "content": audio_input
        }
    },
    timeout=30
)
stt_response.raise_for_status()
transcript = stt_response.json()["transcription"]["transcript"]
print(f"User said: {transcript}")

# Step 2: Send transcript to an LLM via Inworld Router
llm_response = session.post(
    "https://api.inworld.ai/v1/chat/completions",
    headers=headers,
    json={
        "model": "openai/gpt-4o-mini",
        "messages": [
            {"role": "system", "content": "You are a helpful voice assistant. Keep responses under 200 words."},
            {"role": "user", "content": transcript}
        ]
    },
    timeout=30
)
llm_response.raise_for_status()
reply = llm_response.json()["choices"][0]["message"]["content"]
print(f"Assistant: {reply}")

# Step 3: Convert the LLM reply to speech with Inworld TTS
tts_response = session.post(
    "https://api.inworld.ai/tts/v1/voice:stream",
    headers=headers,
    json={
        "voiceId": "Sarah",
        "modelId": "inworld-tts-1.5-max",
        "text": reply
    },
    stream=True
)

audio_chunks = []
for line in tts_response.iter_lines():
    if line:
        data = json.loads(line)
        chunk = base64.b64decode(data["result"]["audioContent"])
        audio_chunks.append(chunk)

audio = b"".join(audio_chunks)
with open("response.mp3", "wb") as f:
    f.write(audio)

print(f"Full pipeline complete: transcription -> reasoning -> speech")

def chunk_text(text, max_chars=1500):
    """Split text at sentence boundaries, keeping chunks under max_chars."""
    import re
    sentences = re.split(r'(?<=[.!?])\s+', text)
    chunks = []
    current = ""

    for sentence in sentences:
        if len(current) + len(sentence) + 1 > max_chars:
            if current:
                chunks.append(current.strip())
            current = sentence
        else:
            current = f"{current} {sentence}" if current else sentence

    if current:
        chunks.append(current.strip())

    return chunks

# Usage: synthesize long text in chunks
long_text = "..." # Any length
for i, chunk in enumerate(chunk_text(long_text)):
    response = session.post(
        "https://api.inworld.ai/tts/v1/voice:stream",
        headers={"Authorization": f"Basic {API_KEY}"},
        json={"voiceId": "Sarah", "modelId": "inworld-tts-1.5-max", "text": chunk},
        stream=True
    )
    # Process each chunk's streaming response...