Get Template by ID

GET https://api.pictory.ai/pictoryapis/v1/templates/{templateId}

import requests

def get_template_details(template_id, api_key):
    """
    Retrieve detailed information about a template
    """
    url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {"Authorization": api_key}

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

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

        print(f"Template: {template['name']}")
        print(f"Language: {template['language']}")
        print(f"Schema: {template['schemaVersion']}")
        print(f"\nSettings:")
        print(f"  Background Music: {'Enabled' if template.get('backgroundMusic', {}).get('enabled') else 'Disabled'}")
        print(f"  Voice Over: {'Enabled' if template.get('voiceOver', {}).get('enabled') else 'Disabled'}")
        print(f"\nStructure:")
        print(f"  Scenes: {len(template['scenes'])}")
        print(f"  Variables: {', '.join(template.get('variables', {}).keys())}")

        return template
    else:
        print(f"Error: {response.status_code}")
        return None

# Example usage
template = get_template_details("YOUR_TEMPLATE_ID", "YOUR_API_KEY")

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

  const template = await response.json();

  // Extract variables from template
  const variables = template.variables || {};

  console.log(`Template: ${template.name}`);
  console.log(`\nCustomizable Variables:`);

  Object.entries(variables).forEach(([key, defaultValue]) => {
    console.log(`  - ${key}: ${defaultValue}`);
  });

  // Also check for variables in subtitles
  const subtitleVariables = new Set();
  template.scenes.forEach(scene => {
    scene.subtitles?.forEach(subtitle => {
      const matches = subtitle.text.match(/\{\{(\w+)\}\}/g);
      if (matches) {
        matches.forEach(match => {
          const varName = match.replace(/\{\{|\}\}/g, '');
          subtitleVariables.add(varName);
        });
      }
    });
  });

  console.log(`\nVariables used in subtitles:`);
  subtitleVariables.forEach(v => console.log(`  - ${v}`));

  return {
    defined: variables,
    usedInSubtitles: Array.from(subtitleVariables)
  };
}

// Example usage
const vars = await getTemplateVariables('YOUR_TEMPLATE_ID', 'YOUR_API_KEY');

import requests

def analyze_template_structure(template_id, api_key):
    """
    Analyze template structure and generate report
    """
    url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {"Authorization": api_key}

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

    # Analyze structure
    analysis = {
        'name': template['name'],
        'language': template['language'],
        'schema_version': template['schemaVersion'],
        'total_scenes': len(template['scenes']),
        'has_background_music': template.get('backgroundMusic', {}).get('enabled', False),
        'has_voice_over': template.get('voiceOver', {}).get('enabled', False),
        'variables': list(template.get('variables', {}).keys()),
        'scene_details': []
    }

    # Analyze each scene
    for i, scene in enumerate(template['scenes'], 1):
        scene_info = {
            'scene_number': i,
            'scene_id': scene['sceneId'],
            'subtitle_count': len(scene.get('subtitles', [])),
            'layer_count': sum(len(layer_group) for layer_group in scene.get('layers', []))
        }
        analysis['scene_details'].append(scene_info)

    # Print report
    print(f"=== Template Analysis: {analysis['name']} ===\n")
    print(f"Language: {analysis['language']}")
    print(f"Schema: {analysis['schema_version']}")
    print(f"Total Scenes: {analysis['total_scenes']}")
    print(f"Background Music: {'Yes' if analysis['has_background_music'] else 'No'}")
    print(f"Voice Over: {'Yes' if analysis['has_voice_over'] else 'No'}")
    print(f"Variables: {', '.join(analysis['variables']) if analysis['variables'] else 'None'}")

    print(f"\nScene Breakdown:")
    for scene in analysis['scene_details']:
        print(f"  Scene {scene['scene_number']}:")
        print(f"    Subtitles: {scene['subtitle_count']}")
        print(f"    Layers: {scene['layer_count']}")

    return analysis

# Example usage
analysis = analyze_template_structure("YOUR_TEMPLATE_ID", "YOUR_API_KEY")

import requests

def compare_templates(template_id_1, template_id_2, api_key):
    """
    Compare two templates and identify differences
    """
    headers = {"Authorization": api_key}
    url = "https://api.pictory.ai/pictoryapis/v1/templates/"

    # Fetch both templates
    template1 = requests.get(f"{url}{template_id_1}", headers=headers).json()
    template2 = requests.get(f"{url}{template_id_2}", headers=headers).json()

    differences = []

    # Compare basic properties
    if template1['name'] != template2['name']:
        differences.append(f"Name: '{template1['name']}' vs '{template2['name']}'")

    if template1['language'] != template2['language']:
        differences.append(f"Language: '{template1['language']}' vs '{template2['language']}'")

    if len(template1['scenes']) != len(template2['scenes']):
        differences.append(f"Scene count: {len(template1['scenes'])} vs {len(template2['scenes'])}")

    # Compare variables
    vars1 = set(template1.get('variables', {}).keys())
    vars2 = set(template2.get('variables', {}).keys())

    if vars1 != vars2:
        added = vars2 - vars1
        removed = vars1 - vars2
        if added:
            differences.append(f"Variables added: {', '.join(added)}")
        if removed:
            differences.append(f"Variables removed: {', '.join(removed)}")

    # Print comparison
    print(f"=== Template Comparison ===")
    print(f"Template 1: {template1['name']} ({template_id_1})")
    print(f"Template 2: {template2['name']} ({template_id_2})")

    if differences:
        print(f"\nDifferences found:")
        for diff in differences:
            print(f"  - {diff}")
    else:
        print("\nNo significant differences found")

    return differences

# Example usage
compare_templates("TEMPLATE_ID_1", "TEMPLATE_ID_2", "YOUR_API_KEY")

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

  const template = await response.json();

  // Create backup object
  const backup = {
    exportDate: new Date().toISOString(),
    templateData: template
  };

  // In Node.js, save to file
  const fs = require('fs');
  const filename = `template_${templateId}_${Date.now()}.json`;

  fs.writeFileSync(filename, JSON.stringify(backup, null, 2));

  console.log(`Template configuration saved to ${filename}`);

  // Also download project and structure files if needed
  if (template.project) {
    console.log(`Project URL: ${template.project}`);
  }
  if (template.structure) {
    console.log(`Structure URL: ${template.structure}`);
  }

  return backup;
}

// Example usage
await downloadTemplateConfiguration('YOUR_TEMPLATE_ID', 'YOUR_API_KEY');

import requests

def validate_template(template_id, api_key):
    """
    Validate template before using it to create videos
    """
    url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {"Authorization": api_key}

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

        if response.status_code != 200:
            return False, f"Failed to fetch template: {response.status_code}"

        template = response.json()

        # Validation checks
        issues = []

        # Check if published
        if not template.get('published'):
            issues.append("Template is not published")

        # Check if deprecated
        if template.get('depricated'):
            issues.append("Template is deprecated")

        # Check for scenes
        if not template.get('scenes'):
            issues.append("Template has no scenes")

        # Check for empty variables
        variables = template.get('variables', {})
        if variables and any(not v for v in variables.values()):
            issues.append("Template has empty variable placeholders")

        # Report results
        if issues:
            print(f"Template validation failed:")
            for issue in issues:
                print(f"  ✗ {issue}")
            return False, issues
        else:
            print(f"✓ Template '{template['name']}' is valid and ready to use")
            return True, None

    except Exception as e:
        return False, f"Error validating template: {str(e)}"

# Example usage
is_valid, issues = validate_template("YOUR_TEMPLATE_ID", "YOUR_API_KEY")