Text to Speech

const { AudioPodClient } = require('audiopod-js');
const fs = require('fs');

// Initialize client
const client = new AudioPodClient();

async function generateSpeech() {
  try {
    // Generate speech using voice UUID
    const job = await client.voice.generateSpeech(
      '550e8400-e29b-41d4-a716-446655440000',  // Voice ID/UUID
      'Hello! This is AudioPod AI generating natural speech.',  // Text
      {
        language: 'en',
        audioFormat: 'mp3',
        generationParams: {
          speed: 1.0
        }
      }
    );

    console.log(`Generation job created: ${job.id}`);
    console.log(`Status: ${job.status}`);

    // Check job status until completion
    while (true) {
      const status = await client.voice.getJobStatus(job.id);
      console.log(`Job status: ${status.status}`);
      
      if (status.status === 'completed') {
        const audioUrl = status.output_url;
        console.log(`Audio ready: ${audioUrl}`);
        
        // Download the audio file
        const fetch = require('node-fetch');
        const audioResponse = await fetch(audioUrl);
        const buffer = await audioResponse.buffer();
        fs.writeFileSync('generated_speech.mp3', buffer);
        console.log('Audio saved as generated_speech.mp3');
        break;
      } else if (status.status === 'failed') {
        console.log(`Job failed: ${status.error_message}`);
        break;
      }
      
      await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds
    }

  } catch (error) {
    console.error('Error:', error.message);
  }
}

generateSpeech();

import requests
import time

# Create TTS job using voice UUID
response = requests.post(
    "https://api.audiopod.ai/api/v1/voice/voices/550e8400-e29b-41d4-a716-446655440000/generate",
    headers={"X-API-Key": api_key},
    data={
        "input_text": "Hello! This is AudioPod AI generating natural speech.",
        "audio_format": "mp3",
        "speed": 1.0,
        "language": "en"
    }
)

if response.status_code == 200:
    job_data = response.json()
    job_id = job_data["job_id"]
    print(f"Voice generation job created: {job_id}")
    print(f"Credits reserved: {job_data.get('credits_reserved')}")
    
    # Poll job status until completion
    while True:
        status_response = requests.get(
            f"https://api.audiopod.ai/api/v1/voice/tts-jobs/{job_id}/status",
            headers={"X-API-Key": api_key}
        )
        
        if status_response.status_code == 200:
            status_data = status_response.json()
            print(f"Job status: {status_data['status']}")
            
            if status_data['status'] == 'completed':
                audio_url = status_data['output_url']
                print(f"Audio ready: {audio_url}")
                
                # Download the audio file
                audio_response = requests.get(audio_url)
                with open("generated_speech.mp3", "wb") as f:
                    f.write(audio_response.content)
                print("Audio saved as generated_speech.mp3")
                break
            elif status_data['status'] == 'failed':
                print(f"Job failed: {status_data.get('error_message')}")
                break
                
        time.sleep(2)  # Wait 2 seconds before checking again

# Create TTS job using voice UUID
JOB_RESPONSE=$(curl -s -X POST "https://api.audiopod.ai/api/v1/voice/voices/550e8400-e29b-41d4-a716-446655440000/generate" \
  -H "X-API-Key: $AUDIOPOD_API_KEY" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d 'input_text=Hello! This is AudioPod AI generating natural speech.' \
  -d 'audio_format=mp3' \
  -d 'speed=1.0' \
  -d 'language=en')

# Extract job ID
JOB_ID=$(echo $JOB_RESPONSE | jq -r '.job_id')
echo "Job created: $JOB_ID"

# Poll job status
while true; do
  STATUS_RESPONSE=$(curl -s -X GET "https://api.audiopod.ai/api/v1/voice/tts-jobs/$JOB_ID/status" \
    -H "X-API-Key: $AUDIOPOD_API_KEY")
  
  STATUS=$(echo $STATUS_RESPONSE | jq -r '.status')
  echo "Job status: $STATUS"
  
  if [ "$STATUS" = "completed" ]; then
    AUDIO_URL=$(echo $STATUS_RESPONSE | jq -r '.output_url')
    echo "Audio ready: $AUDIO_URL"
    
    # Download the audio
    curl -o generated_speech.mp3 "$AUDIO_URL"
    echo "Audio saved as generated_speech.mp3"
    break
  elif [ "$STATUS" = "failed" ]; then
    echo "Job failed"
    break
  fi
  
  sleep 2
done

const { AudioPodClient } = require('audiopod-js');
const client = new AudioPodClient();

async function demonstrateVoiceIdentification() {
  try {
    // Using standard pre-built voice by name
    const job1 = await client.voice.generateSpeech({
      voiceIdentifier: 'aura',  // Standard voice name
      inputText: 'Hello! This uses a standard pre-built voice.',
      audioFormat: 'mp3',
      speed: 1.0
    });
    console.log(`Standard voice job: ${job1.jobId}`);

    // Using custom voice clone (by integer ID)
    const job2 = await client.voice.generateSpeech({
      voiceIdentifier: 123,  // Your custom voice ID
      inputText: 'Hello! This uses my custom cloned voice.',
      audioFormat: 'mp3',
      speed: 1.0
    });
    console.log(`Custom voice job: ${job2.jobId}`);

    // Using voice via UUID (works for both standard and custom voices)
    const job3 = await client.voice.generateSpeech({
      voiceIdentifier: '550e8400-e29b-41d4-a716-446655440000',  // Voice UUID
      inputText: 'Hello! This uses voice identification via UUID.',
      audioFormat: 'mp3',
      speed: 1.0
    });
    console.log(`UUID voice job: ${job3.jobId}`);

    // List available voices
    const voices = await client.voice.listVoices({ includePublic: true });
    console.log('Available voices:');
    voices.forEach(voice => {
      console.log(`- ${voice.name} (UUID: ${voice.uuid}): ${voice.description}`);
    });

  } catch (error) {
    console.error('Error:', error.message);
  }
}

demonstrateVoiceIdentification();

import requests

headers = {"X-API-Key": api_key}

# Generate with a standard voice by name
response1 = requests.post(
    "https://api.audiopod.ai/api/v1/voice/voices/aura/generate",
    headers=headers,
    data={
        "input_text": "Hello! This uses a standard pre-built voice.",
        "audio_format": "mp3",
        "speed": 1.0
    }
)
print(f"Standard voice job: {response1.json()['job_id']}")

# Generate with your custom voice by ID
response2 = requests.post(
    "https://api.audiopod.ai/api/v1/voice/voices/123/generate",  # Your custom voice ID
    headers=headers,
    data={
        "input_text": "Hello! This uses my custom cloned voice.",
        "audio_format": "mp3",
        "speed": 1.0
    }
)
print(f"Custom voice job: {response2.json()['job_id']}")

# Generate with voice using UUID
response3 = requests.post(
    "https://api.audiopod.ai/api/v1/voice/voices/550e8400-e29b-41d4-a716-446655440000/generate",
    headers=headers,
    data={
        "input_text": "Hello! This uses voice identification via UUID.",
        "audio_format": "mp3",
        "speed": 1.0
    }
)
print(f"UUID voice job: {response3.json()['job_id']}")

# List available voices
voices_response = requests.get(
    "https://api.audiopod.ai/api/v1/voice/voice-profiles?include_public=true",
    headers=headers
)
voices = voices_response.json()
print("Available voices:")
for voice in voices:
    print(f"- {voice['name']} (UUID: {voice['uuid']}): {voice['description']}")

const { AudioPodClient } = require('audiopod-js');
const client = new AudioPodClient();

function splitTextBySentences(text, maxLength = 2000) {
  const sentences = text.split(/[.!?]+/);
  const chunks = [];
  let currentChunk = '';
  
  for (const sentence of sentences) {
    if ((currentChunk + sentence).length > maxLength) {
      if (currentChunk) {
        chunks.push(currentChunk.trim());
      }
      currentChunk = sentence;
    } else {
      currentChunk += sentence + '. ';
    }
  }
  
  if (currentChunk) {
    chunks.push(currentChunk.trim());
  }
  
  return chunks;
}

async function createAudiobookChapter(chapterText, narratorVoice = 'sage') {
  try {
    // Split long text into manageable chunks
    const chunks = splitTextBySentences(chapterText, 2000);
    const audioUrls = [];

    for (let i = 0; i < chunks.length; i++) {
      const chunk = chunks[i];
      console.log(`Processing chunk ${i+1}/${chunks.length}: ${chunk.substring(0, 50)}...`);

      const result = await client.voice.generateSpeech({
        voiceId: narratorVoice,
        text: chunk,
        audioFormat: 'wav',  // High quality for audiobooks
        speed: 0.95,  // Slightly slower for audiobooks
        waitForCompletion: true
      });

      audioUrls.push(result.outputUrl);
      console.log(`Generated audio for chunk ${i+1}`);
    }

    return audioUrls;

  } catch (error) {
    console.error('Error creating audiobook:', error.message);
    throw error;
  }
}

// Example usage
const chapterText = `
Chapter 1: The Beginning

It was the best of times, it was the worst of times. The era was filled with
contradictions that would shape the destiny of nations. In this tumultuous
period, heroes would rise and fall, love would conquer fear, and the very
fabric of society would be tested by forces beyond imagination.

As dawn broke over the ancient city, our protagonist began a journey that
would change everything they thought they knew about the world.
`;

createAudiobookChapter(chapterText, 'sage')
  .then(audioUrls => {
    console.log(`Audiobook chapter complete! Generated ${audioUrls.length} audio segments.`);
    audioUrls.forEach((url, index) => {
      console.log(`Segment ${index + 1}: ${url}`);
    });
  })
  .catch(error => {
    console.error('Failed to create audiobook:', error);
  });

from audiopod import Client
import asyncio
import aiohttp
import json

client = Client()

async def create_audiobook_chapter_parallel(chapter_text, narrator_voice="sage"):
    """Create audiobook with parallel processing for faster generation"""
    chunks = split_text_by_sentences(chapter_text, max_length=2000)
    
    # Create all jobs first (parallel creation)
    jobs = []
    for chunk in chunks:
        job = client.voice.generate_speech(
            voice_id=narrator_voice,
            text=chunk,
            audio_format="wav",
            speed=0.95,
            wait_for_completion=False  # Don't wait, create jobs in parallel
        )
        jobs.append(job)
    
    print(f"Created {len(jobs)} generation jobs")
    
    # Wait for all jobs to complete
    audio_urls = []
    for i, job in enumerate(jobs):
        print(f"Waiting for job {i+1}/{len(jobs)}")
        
        # Poll job status
        while True:
            status = client.voice.get_job_status(job.id)
            if status.status == 'completed':
                audio_urls.append(status.output_url)
                break
            elif status.status == 'failed':
                print(f"Job {job.id} failed: {status.error_message}")
                break
            
            await asyncio.sleep(2)
    
    return audio_urls

# Example with error handling and progress tracking
def create_audiobook_with_progress(chapter_text, narrator_voice="sage"):
    """Create audiobook with detailed progress tracking"""
    chunks = split_text_by_sentences(chapter_text, max_length=2000)
    total_chunks = len(chunks)
    completed_chunks = 0
    audio_urls = []
    
    print(f"Starting audiobook generation: {total_chunks} chunks")
    
    for i, chunk in enumerate(chunks):
        try:
            print(f"[{i+1}/{total_chunks}] Processing: {chunk[:50]}...")
            
            result = client.voice.generate_speech(
                voice_id=narrator_voice,
                text=chunk,
                audio_format="wav",
                speed=0.95,
                wait_for_completion=True
            )
            
            audio_urls.append(result.output_url)
            completed_chunks += 1
            
            progress = (completed_chunks / total_chunks) * 100
            print(f"[{i+1}/{total_chunks}] ✅ Complete ({progress:.1f}%)")
            
        except Exception as e:
            print(f"[{i+1}/{total_chunks}] ❌ Failed: {e}")
            # You could implement retry logic here
            
    print(f"Audiobook generation complete! {completed_chunks}/{total_chunks} chunks successful")
    return audio_urls