Text-to-Speech API Quickstart

import requests

# Using default voice (voice_id is optional)
response = requests.post(
    'https://dev.voice.ai/api/v1/tts/speech/stream',
    headers={'Authorization': 'Bearer YOUR_API_KEY', 'Content-Type': 'application/json'},
    json={
        'text': 'This text will be streamed in chunks.',
        'model': 'voiceai-tts-v1-latest',  # Optional, defaults to voiceai-tts-v1-latest
        'language': 'en'  # Optional, defaults to 'en'
    },
    stream=True
)

# Or with a custom voice_id:
# json={'voice_id': 'your-voice-id-here', 'text': 'This text will be streamed in chunks.', 'model': 'voiceai-tts-v1-latest', 'language': 'en'}

with open('output.mp3', 'wb') as f:
    for chunk in response.iter_content():
        if chunk: f.write(chunk)

# Use -N flag to disable buffering for streaming
# Using default voice (voice_id is optional)
curl -N -X POST "https://dev.voice.ai/api/v1/tts/speech/stream" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  --output output.mp3 \
  -d '{
    "text": "This text will be streamed in chunks.",
    "model": "voiceai-tts-v1-latest",
    "language": "en"
  }'

# Or with a custom voice_id:
# -d '{"voice_id": "your-voice-id-here", "text": "This text will be streamed in chunks.", "model": "voiceai-tts-v1-latest", "language": "en"}'

// Using default voice (voice_id is optional)
const response = await fetch('https://dev.voice.ai/api/v1/tts/speech/stream', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    text: 'This text will be streamed in chunks.',
    model: 'voiceai-tts-v1-latest',  // Optional, defaults to voiceai-tts-v1-latest
    language: 'en'  // Optional, defaults to 'en'
    // Or with a custom voice_id:
    // voice_id: 'your-voice-id-here',
  })
});

const reader = response.body!.getReader();
const chunks: Uint8Array[] = [];

while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  if (value) {
    chunks.push(value);
    // Optionally: play chunks as they arrive for real-time playback
  }
}

// Play complete audio
const audioBlob = new Blob(chunks, { type: 'audio/mpeg' });
const audio = new Audio(URL.createObjectURL(audioBlob));
audio.play();

import asyncio
import json
import base64
import websockets

async def tts_conversation():
    # Use /multi-stream for multiple generations over persistent connection
    url = "wss://dev.voice.ai/api/v1/tts/multi-stream"
    headers = {"Authorization": "Bearer YOUR_API_KEY"}
    
    try:
        async with websockets.connect(url, additional_headers=headers) as ws:
            # First message (context auto-generated)
            await ws.send(json.dumps({
                "text": "Hello! How can I help you today?",
                "language": "en",
                "flush": True
            }))
            
            # Receive audio chunks
            while True:
                msg = await ws.recv()
                data = json.loads(msg)
                if data.get("error"):
                    print(f"Error: {data['error']}")
                    break
                if data.get("audio"):
                    audio_chunk = base64.b64decode(data["audio"])
                    # Process/play audio chunk...
                elif data.get("is_last"):
                    break
            
            # Second generation (same connection)
            await ws.send(json.dumps({
                "text": "I can help you with that.",
                "flush": True
            }))
            
            # Receive audio...
            while True:
                msg = await ws.recv()
                data = json.loads(msg)
                if data.get("error"):
                    print(f"Error: {data['error']}")
                    break
                if data.get("audio"):
                    audio_chunk = base64.b64decode(data["audio"])
                    # Process/play audio chunk...
                elif data.get("is_last"):
                    break
            
            # Close when done
            await ws.send(json.dumps({"close_socket": True}))
            
    except websockets.ConnectionClosed as e:
        # Handle connection errors (auth failures, invalid params, etc.)
        # Close codes: 1000=normal, 1003=invalid message, 1007=invalid data,
        #              1008=policy violation (auth/credits), 1011=server error
        print(f"Connection closed: code={e.code} reason={e.reason}")

asyncio.run(tts_conversation())

import WebSocket from 'ws';

// Use /multi-stream for multiple generations over persistent connection
const ws = new WebSocket('wss://dev.voice.ai/api/v1/tts/multi-stream', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

let messageCount = 0;

ws.on('open', () => {
  // First message
  ws.send(JSON.stringify({
    text: 'Hello! How can I help you today?',
    language: 'en',
    flush: true
  }));
});

ws.on('message', (data: Buffer) => {
  const message = JSON.parse(data.toString());
  
  // Handle errors
  if (message.error) {
    console.error('Error:', message.error);
    return;
  }
  
  if (message.audio) {
    const audioChunk = Buffer.from(message.audio, 'base64');
    // Process/play audio chunk...
  } else if (message.is_last) {
    messageCount++;
    if (messageCount === 1) {
      // First message complete, send second
      ws.send(JSON.stringify({
        text: 'I can help you with that.',
        flush: true
      }));
    } else {
      // All done, close connection
      ws.send(JSON.stringify({ close_socket: true }));
    }
  }
});

ws.on('error', (error) => {
  console.error('WebSocket error:', error.message);
});

ws.on('close', (code, reason) => {
  // Handle connection errors (auth failures, invalid params, etc.)
  // Close codes: 1000=normal, 1003=invalid message, 1007=invalid data,
  //              1008=policy violation (auth/credits), 1011=server error
  if (code !== 1000) {
    console.error(`Connection closed with error: code=${code} reason=${reason.toString()}`);
  }
});