Get Voiceover Tracks

GET https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks

import requests

def get_all_voices(api_key):
    """
    Retrieve all available voiceover voices
    """
    url = "https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks"
    headers = {"Authorization": api_key}

    response = requests.get(url, headers=headers)

    if response.status_code == 200:
        voices = response.json()
        print(f"Total available voices: {len(voices)}\n")

        for voice in voices[:10]:  # Show first 10
            print(f"{voice['name']} - {voice['accent']} ({voice['language']})")
            print(f"  Gender: {voice['gender']}, Engine: {voice['engine']}")
            print(f"  Sample: {voice['sample']}")
            print()

        return voices
    else:
        print(f"Error: {response.status_code}")
        return []

# Example usage
voices = get_all_voices("YOUR_API_KEY")

async function getVoicesByLanguage(apiKey, languageCode) {
  const response = await fetch(
    'https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks',
    {
      headers: { 'Authorization': `${apiKey}` }
    }
  );

  const allVoices = await response.json();

  // Filter by language code (e.g., "en-US", "en-GB", "fr-FR")
  const filtered = allVoices.filter(voice => voice.language === languageCode);

  console.log(`Found ${filtered.length} voices for ${languageCode}:`);
  filtered.forEach(voice => {
    console.log(`  - ${voice.name} (${voice.accent}, ${voice.gender})`);
  });

  return filtered;
}

// Example usage
const usVoices = await getVoicesByLanguage('YOUR_API_KEY', 'en-US');

from collections import defaultdict
import requests

def group_voices_by_accent(api_key):
    """
    Group voices by their accent
    """
    url = "https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks"
    headers = {"Authorization": api_key}

    response = requests.get(url, headers=headers)
    voices = response.json()

    # Group by accent
    by_accent = defaultdict(list)
    for voice in voices:
        accent = voice.get('accent', 'Unknown')
        by_accent[accent].append(voice)

    # Print grouped results
    for accent, voice_list in sorted(by_accent.items()):
        print(f"\n{accent} ({len(voice_list)} voices):")
        for voice in voice_list[:5]:  # Show first 5 per accent
            print(f"  - {voice['name']} ({voice['gender']}, {voice['engine']})")

    return by_accent

# Example usage
grouped = group_voices_by_accent("YOUR_API_KEY")

async function findVoiceMatch(apiKey, criteria) {
  const response = await fetch(
    'https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks',
    {
      headers: { 'Authorization': `${apiKey}` }
    }
  );

  const voices = await response.json();

  // Filter by multiple criteria
  const matches = voices.filter(voice => {
    return (
      (!criteria.language || voice.language === criteria.language) &&
      (!criteria.gender || voice.gender === criteria.gender) &&
      (!criteria.accent || voice.accent.toLowerCase().includes(criteria.accent.toLowerCase())) &&
      (!criteria.service || voice.service === criteria.service) &&
      (!criteria.engine || voice.engine === criteria.engine)
    );
  });

  console.log(`Found ${matches.length} matching voices:`);
  matches.forEach(voice => {
    console.log(`  - ${voice.name} (ID: ${voice.id})`);
    console.log(`    ${voice.accent}, ${voice.gender}, ${voice.engine}`);
  });

  return matches;
}

// Example usage - find American female neural voices
const matches = await findVoiceMatch('YOUR_API_KEY', {
  language: 'en-US',
  gender: 'female',
  accent: 'American',
  engine: 'neural'
});

import requests

def prepare_voice_ui_data(api_key, language_filter=None):
    """
    Prepare voice data structured for UI dropdowns/selectors
    """
    url = "https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks"
    headers = {"Authorization": api_key}

    response = requests.get(url, headers=headers)
    voices = response.json()

    # Filter by language if specified
    if language_filter:
        voices = [v for v in voices if v['language'] == language_filter]

    # Structure for UI
    ui_data = {
        'languages': {},
        'accents': {},
        'genders': ['male', 'female'],
        'engines': set(),
        'voices': []
    }

    for voice in voices:
        # Collect unique languages
        lang = voice['language']
        if lang not in ui_data['languages']:
            ui_data['languages'][lang] = []
        ui_data['languages'][lang].append(voice['name'])

        # Collect unique accents
        accent = voice['accent']
        if accent not in ui_data['accents']:
            ui_data['accents'][accent] = []
        ui_data['accents'][accent].append(voice['name'])

        # Collect engines
        ui_data['engines'].add(voice['engine'])

        # Create simplified voice entry
        ui_data['voices'].append({
            'id': voice['id'],
            'name': voice['name'],
            'label': f"{voice['name']} ({voice['accent']}, {voice['gender']})",
            'language': voice['language'],
            'accent': voice['accent'],
            'gender': voice['gender'],
            'engine': voice['engine'],
            'service': voice['service'],
            'sample': voice['sample']
        })

    ui_data['engines'] = sorted(list(ui_data['engines']))

    print(f"Prepared UI data for {len(ui_data['voices'])} voices")
    print(f"Languages: {len(ui_data['languages'])}")
    print(f"Accents: {len(ui_data['accents'])}")
    print(f"Engines: {ui_data['engines']}")

    return ui_data

# Example usage
ui_data = prepare_voice_ui_data("YOUR_API_KEY", language_filter="en-US")

# Access structured data
print("\nSample voice entries:")
for voice in ui_data['voices'][:3]:
    print(f"  {voice['label']} - ID: {voice['id']}")

import requests

def compare_voice_providers(api_key):
    """
    Compare voice offerings between AWS and Google
    """
    url = "https://api.pictory.ai/pictoryapis/v1/voiceovers/tracks"
    headers = {"Authorization": api_key}

    response = requests.get(url, headers=headers)
    voices = response.json()

    # Separate by provider
    aws_voices = [v for v in voices if v['service'] == 'aws']
    google_voices = [v for v in voices if v['service'] == 'google']

    print("Voice Provider Comparison:")
    print(f"\nAWS Polly: {len(aws_voices)} voices")
    print(f"  Engines: {set(v['engine'] for v in aws_voices)}")
    print(f"  Languages: {len(set(v['language'] for v in aws_voices))}")
    print(f"  Male: {len([v for v in aws_voices if v['gender'] == 'male'])}")
    print(f"  Female: {len([v for v in aws_voices if v['gender'] == 'female'])}")

    print(f"\nGoogle Cloud: {len(google_voices)} voices")
    print(f"  Engines: {set(v['engine'] for v in google_voices)}")
    print(f"  Languages: {len(set(v['language'] for v in google_voices))}")
    print(f"  Male: {len([v for v in google_voices if v['gender'] == 'male'])}")
    print(f"  Female: {len([v for v in google_voices if v['gender'] == 'female'])}")

    # Language overlap
    aws_langs = set(v['language'] for v in aws_voices)
    google_langs = set(v['language'] for v in google_voices)
    common_langs = aws_langs & google_langs

    print(f"\nLanguages available in both: {len(common_langs)}")
    print(f"AWS only: {len(aws_langs - google_langs)}")
    print(f"Google only: {len(google_langs - aws_langs)}")

    return {
        'aws': aws_voices,
        'google': google_voices,
        'stats': {
            'aws_count': len(aws_voices),
            'google_count': len(google_voices),
            'common_languages': list(common_langs)
        }
    }

# Example usage
comparison = compare_voice_providers("YOUR_API_KEY")