Text-to-Speech

import requests

def text_to_speech(text, model="Kokoro-82m", voice=None, **kwargs):
    headers = {
        "x-api-key": "YOUR_API_KEY",
        "Content-Type": "application/json"
    }
    
    payload = {
        "text": text,
        "model": model
    }
    
    if voice:
        payload["voice"] = voice
    
    payload.update(kwargs)
    
    response = requests.post(
        "https://nano-gpt.com/api/tts",
        headers=headers,
        json=payload
    )
    
    if response.status_code == 200:
        content_type = response.headers.get('content-type', '')
        
        if 'application/json' in content_type:
            # JSON response with audio URL
            data = response.json()
            audio_response = requests.get(data['audioUrl'])
            with open('output.wav', 'wb') as f:
                f.write(audio_response.content)
        else:
            # Binary audio data (OpenAI models)
            with open('output.mp3', 'wb') as f:
                f.write(response.content)
        
        return response
    else:
        raise Exception(f"Error: {response.status_code}")

# Basic usage
text_to_speech(
    "Hello! Welcome to our service.",
    model="Kokoro-82m",
    voice="af_bella"
)

async function textToSpeech(text, options = {}) {
    const payload = {
        text: text,
        model: options.model || 'Kokoro-82m',
        ...options
    };
    
    const response = await fetch('https://nano-gpt.com/api/tts', {
        method: 'POST',
        headers: {
            'x-api-key': 'YOUR_API_KEY',
            'Content-Type': 'application/json'
        },
        body: JSON.stringify(payload)
    });
    
    if (response.ok) {
        const contentType = response.headers.get('content-type');
        
        if (contentType.includes('application/json')) {
            const data = await response.json();
            console.log('Audio URL:', data.audioUrl);
            return data;
        } else {
            // Binary audio data
            const audioBlob = await response.blob();
            const url = URL.createObjectURL(audioBlob);
            console.log('Audio blob URL:', url);
            return { audioBlob, url };
        }
    } else {
        throw new Error(`Error: ${response.status}`);
    }
}

// Usage
textToSpeech('Hello world!', {
    model: 'Kokoro-82m',
    voice: 'af_bella',
    speed: 1.1
});

curl -X POST https://nano-gpt.com/api/tts \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Hello! Welcome to our service.",
    "model": "Kokoro-82m",
    "voice": "af_bella",
    "speed": 1.0
  }'

# 1) Submit TTS
curl -X POST https://nano-gpt.com/api/tts \
  -H 'x-api-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "text": "Hello there!",
    "model": "Elevenlabs-Turbo-V2.5",
    "voice": "Rachel",
    "speed": 1.0
  }'

# 2) If response is 202/pending, poll using returned values
curl "https://nano-gpt.com/api/tts/status?runId=98b0d593-fe8d-49b8-89c9-233022232297&model=Elevenlabs-Turbo-V2.5&cost=0.0050388&paymentSource=USD&isApiRequest=true" \
  -H 'x-api-key: YOUR_API_KEY'

# 3) On completion, you'll receive an audioUrl
# {
#   "status": "completed",
#   "audioUrl": "https://.../file.mp3",
#   "contentType": "audio/mpeg",
#   "model": "Elevenlabs-Turbo-V2.5"
# }

async function submitTTS({ text, model = 'Elevenlabs-Turbo-V2.5', voice = 'Rachel', speed = 1 }) {
  const res = await fetch('https://nano-gpt.com/api/tts', {
    method: 'POST',
    headers: {
      'x-api-key': 'YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ text, model, voice, speed })
  });

  if (res.status === 202) {
    const ticket = await res.json();
    return await pollTTSStatus(ticket);
  }

  if (!res.ok) {
    const err = await res.json().catch(() => ({}));
    throw new Error(err.error || 'TTS request failed');
  }

  // Synchronous: either JSON with URL or binary audio
  const ct = res.headers.get('content-type') || '';
  if (ct.includes('application/json')) {
    const json = await res.json();
    return json.audioUrl;
  }

  const blob = await res.blob();
  return URL.createObjectURL(blob); // play via <audio src={...}>
}

async function pollTTSStatus({ runId, model, cost, paymentSource, isApiRequest }) {
  const maxAttempts = 60; // ~3 minutes at 3s interval
  const intervalMs = 3000;

  for (let i = 0; i < maxAttempts; i++) {
    const qs = new URLSearchParams({ runId, model });
    if (typeof cost === 'number') qs.set('cost', String(cost));
    if (paymentSource) qs.set('paymentSource', String(paymentSource));
    if (typeof isApiRequest === 'boolean') qs.set('isApiRequest', String(isApiRequest));

    const res = await fetch(`https://nano-gpt.com/api/tts/status?${qs.toString()}`, {
      headers: { 'x-api-key': 'YOUR_API_KEY' }
    });
    if (!res.ok) {
      const err = await res.json().catch(() => ({}));
      throw new Error(err.error || `Polling failed (${res.status})`);
    }

    const data = await res.json();
    if (data.status === 'completed' && data.audioUrl) return data.audioUrl;
    if (data.status === 'error') throw new Error(data.error || 'TTS generation failed');

    await new Promise(r => setTimeout(r, intervalMs));
  }

  throw new Error('Polling timeout');
}

# Popular voice examples by category
voices = {
    "american_female": ["af_bella", "af_nova", "af_aoede"],
    "american_male": ["am_adam", "am_onyx", "am_eric"],
    "british_female": ["bf_alice", "bf_emma"],
    "british_male": ["bm_daniel", "bm_george"],
    "japanese_female": ["jf_alpha", "jf_gongitsune"],
    "chinese_female": ["zf_xiaoxiao", "zf_xiaoyi"],
    "french_female": ["ff_siwis"],
    "italian_male": ["im_nicola"]
}

# Generate multilingual samples
samples = [
    {"text": "Hello, welcome!", "voice": "af_bella", "lang": "English"},
    {"text": "Bonjour et bienvenue!", "voice": "ff_siwis", "lang": "French"},
    {"text": "こんにちは！", "voice": "jf_alpha", "lang": "Japanese"},
    {"text": "你好，欢迎！", "voice": "zf_xiaoxiao", "lang": "Chinese"}
]

for sample in samples:
    text_to_speech(
        text=sample["text"],
        model="Kokoro-82m",
        voice=sample["voice"]
    )

# Stable, consistent voice
text_to_speech(
    text="This is a professional announcement.",
    model="Elevenlabs-Turbo-V2.5",
    voice="Rachel",
    stability=0.9,
    similarity_boost=0.8,
    style=0
)

# Expressive, dynamic voice  
text_to_speech(
    text="This is so exciting!",
    model="Elevenlabs-Turbo-V2.5",
    voice="Rachel",
    stability=0.3,
    similarity_boost=0.7,
    style=0.8,
    speed=1.2
)

# Available voices: Rachel, Adam, Bella, Brian, etc.

curl -X POST https://nano-gpt.com/api/tts \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Welcome to our premium service!",
    "model": "Elevenlabs-Turbo-V2.5",
    "voice": "Rachel",
    "stability": 0.7,
    "similarity_boost": 0.8,
    "style": 0.3
  }'

# High-definition with voice instructions
text_to_speech(
    text="Welcome to customer service.",
    model="tts-1-hd",
    voice="nova",
    instructions="Speak warmly and professionally like a customer service representative",
    response_format="flac"
)

# Ultra-low cost option
text_to_speech(
    text="This is a cost-effective option.",
    model="gpt-4o-mini-tts",
    voice="alloy",
    instructions="Speak clearly and cheerfully",
    response_format="mp3"
)

# Different format examples
formats = ["mp3", "wav", "opus", "flac", "aac"]
for fmt in formats:
    text_to_speech(
        text=f"This is {fmt.upper()} format.",
        model="tts-1",
        voice="echo",
        response_format=fmt
    )

# With voice instructions
curl -X POST https://nano-gpt.com/api/tts \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Breaking news update!",
    "model": "tts-1-hd",
    "voice": "nova",
    "instructions": "Speak with the urgency of a news reporter",
    "response_format": "wav"
  }'

# Ultra-low cost
curl -X POST https://nano-gpt.com/api/tts \
  -H "x-api-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Budget-friendly text-to-speech.",
    "model": "gpt-4o-mini-tts",
    "voice": "alloy"
  }'

try:
    result = text_to_speech("Hello world!", model="Kokoro-82m")
    print("Success!")
except Exception as e:
    if "400" in str(e):
        print("Bad request - check parameters")
    elif "401" in str(e):
        print("Unauthorized - check API key")
    elif "413" in str(e):
        print("Text too long for model")
    else:
        print(f"Error: {e}")