List Templates

GET https://api.pictory.ai/pictoryapis/v1/templates

import requests

def get_all_templates(api_key):
    """
    Retrieve all templates associated with the account
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {"Authorization": api_key}

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

    if response.status_code == 200:
        data = response.json()
        templates = data.get('items', [])

        print(f"Found {len(templates)} templates:")
        for template in templates:
            status = "Published" if template['published'] else "Draft"
            deprecated = " (Deprecated)" if template.get('deprecated') else ""
            print(f"  - {template['name']} ({status}){deprecated}")
            print(f"    ID: {template['templateId']}")

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

# Example usage
templates = get_all_templates("YOUR_API_KEY")

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

  const data = await response.json();

  // Filter for published, non-deprecated templates
  const publishedTemplates = data.items.filter(
    template => template.published && !template.deprecated
  );

  console.log(`Found ${publishedTemplates.length} published templates:`);
  publishedTemplates.forEach(template => {
    console.log(`  - ${template.name} (${template.templateId})`);
  });

  return publishedTemplates;
}

// Example usage
const templates = await getPublishedTemplates('YOUR_API_KEY');

from collections import defaultdict
import requests

def group_templates_by_language(api_key):
    """
    Group templates by language code
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {"Authorization": api_key}

    response = requests.get(url, headers=headers)
    data = response.json()
    templates = data.get('items', [])

    # Group by language
    by_language = defaultdict(list)
    for template in templates:
        language = template.get('language', 'unknown')
        by_language[language].append(template)

    # Print grouped results
    for language, template_list in by_language.items():
        print(f"\n{language.upper()} Templates ({len(template_list)}):")
        for template in template_list:
            print(f"  - {template['name']}")

    return by_language

# Example usage
grouped = group_templates_by_language("YOUR_API_KEY")

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

  const data = await response.json();

  // Case-insensitive search
  const found = data.items.filter(
    template => template.name.toLowerCase().includes(searchName.toLowerCase())
  );

  if (found.length > 0) {
    console.log(`Found ${found.length} matching template(s):`);
    found.forEach(template => {
      console.log(`  - ${template.name} (ID: ${template.templateId})`);
    });
    return found;
  } else {
    console.log(`No templates found matching: ${searchName}`);
    return [];
  }
}

// Example usage
const results = await findTemplateByName('YOUR_API_KEY', 'Corporate');

import requests
import json
from datetime import datetime

def export_template_list(api_key, output_file="templates.json"):
    """
    Export all templates to a JSON file
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {"Authorization": api_key}

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

    if response.status_code == 200:
        data = response.json()

        # Create export data with metadata
        export_data = {
            "exportDate": datetime.now().isoformat(),
            "totalTemplates": len(data.get('items', [])),
            "templates": data.get('items', [])
        }

        # Write to file
        with open(output_file, 'w') as f:
            json.dump(export_data, f, indent=2)

        print(f"Exported {export_data['totalTemplates']} templates to {output_file}")
        return export_data
    else:
        print(f"Error: {response.status_code}")
        return None

# Example usage
export_template_list("YOUR_API_KEY", "my_templates.json")

import requests

def get_template_summary(api_key):
    """
    Generate a summary of template statuses
    """
    url = "https://api.pictory.ai/pictoryapis/v1/templates"
    headers = {"Authorization": api_key}

    response = requests.get(url, headers=headers)
    data = response.json()
    templates = data.get('items', [])

    # Calculate statistics
    total = len(templates)
    published = sum(1 for t in templates if t.get('published'))
    deprecated = sum(1 for t in templates if t.get('deprecated'))
    active = sum(1 for t in templates if t.get('published') and not t.get('deprecated'))

    # Print summary
    print("Template Summary:")
    print(f"  Total Templates: {total}")
    print(f"  Published: {published}")
    print(f"  Deprecated: {deprecated}")
    print(f"  Active (Published & Not Deprecated): {active}")
    print(f"  Draft: {total - published}")

    # Languages breakdown
    languages = {}
    for template in templates:
        lang = template.get('language', 'unknown')
        languages[lang] = languages.get(lang, 0) + 1

    print("\nTemplates by Language:")
    for lang, count in sorted(languages.items()):
        print(f"  {lang}: {count}")

    return {
        'total': total,
        'published': published,
        'deprecated': deprecated,
        'active': active,
        'languages': languages
    }

# Example usage
summary = get_template_summary("YOUR_API_KEY")