Skip to main content
DELETE
https://api.pictory.ai
/
pictoryapis
/
v1
/
templates
/
{templateId}
Delete Template
curl --request DELETE \
  --url https://api.pictory.ai/pictoryapis/v1/templates/{templateId} \
  --header 'Authorization: <authorization>'
{
  "success": true,
  "message": "Template deleted successfully"
}

​
Overview

Permanently delete a video template from your Pictory account using its unique identifier. This action removes the template and all its configuration data, including scene structures, variables, and settings.
This action is permanent and cannot be undone. Once deleted, the template and all its configuration will be permanently removed from your account. Videos already created from this template will not be affected.
You need a valid API key to use this endpoint. Get your API key from the API Access page in your Pictory dashboard.

​
API Endpoint

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

​
Request Parameters

​
Path Parameters

​
templateId
string
required
The unique identifier of the template to deleteExample: 202512230204424435786014d42904bbc95813430789fe736

​
Headers

​
Authorization
string
required
API key for authentication (starts with pictai_)
Authorization: YOUR_API_KEY

​
Response

​
success
boolean
Indicates whether the deletion was successful
​
message
string
Confirmation message about the deletion

​
Response Examples

{
  "success": true,
  "message": "Template deleted successfully"
}

​
Code Examples

Replace YOUR_API_KEY with your actual API key that starts with pictai_
curl --request DELETE \
  --url 'https://api.pictory.ai/pictoryapis/v1/templates/YOUR_TEMPLATE_ID' \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'accept: application/json' | python -m json.tool

​
Usage Notes

Permanent Deletion: Deleted templates cannot be recovered. Ensure you have backups of template configurations before deleting.
Before deleting a template, consider using the Get Template By Id endpoint to retrieve and back up the complete template configuration for archival purposes.
Existing Videos: Videos that were already created from this template will continue to exist and function normally. Only the template itself is deleted.
Permission Requirements: You can only delete templates that belong to your account or team. Attempting to delete templates from other accounts will result in a 403 Forbidden error.

​
Common Use Cases

​
1. Delete Single Template with Confirmation

Delete a template after user confirmation: 
import requests

def delete_template_with_confirmation(template_id, api_key):
    """
    Delete a template after confirming with the user
    """
    # First, get template details
    get_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    headers = {"Authorization": api_key}

    template_response = requests.get(get_url, headers=headers)

    if template_response.status_code != 200:
        print("Template not found")
        return False

    template = template_response.json()
    template_name = template.get('name', 'Unknown')

    # Confirm deletion
    print(f"Are you sure you want to delete template '{template_name}'? (yes/no)")
    confirmation = input().strip().lower()

    if confirmation != 'yes':
        print("Deletion cancelled")
        return False

    # Delete template
    delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    delete_response = requests.delete(delete_url, headers=headers)

    if delete_response.status_code in [200, 204]:
        print(f"Template '{template_name}' deleted successfully")
        return True
    else:
        try:
            result = delete_response.json()
            print(f"Failed to delete template: {result.get('message')}")
        except:
            print(f"Failed to delete template: HTTP {delete_response.status_code}")
        return False

# Example usage
delete_template_with_confirmation("YOUR_TEMPLATE_ID", "YOUR_API_KEY")

​
2. Bulk Delete Deprecated Templates

Delete all deprecated templates: 
import requests

def delete_deprecated_templates(api_key, dry_run=True):
    """
    Delete all deprecated templates
    """
    headers = {"Authorization": api_key}

    # Get all templates
    list_url = "https://api.pictory.ai/pictoryapis/v1/templates"
    response = requests.get(list_url, headers=headers)
    templates = response.json().get('items', [])

    # Find deprecated templates
    deprecated_templates = [
        t for t in templates
        if t.get('depricated') or t.get('deprecated')
    ]

    print(f"Found {len(deprecated_templates)} deprecated templates")

    if dry_run:
        print("DRY RUN - Templates that would be deleted:")
        for template in deprecated_templates:
            print(f"  - {template.get('name', 'Unknown')} (ID: {template['templateId']})")
        return

    # Delete deprecated templates
    deleted_count = 0
    for template in deprecated_templates:
        delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template['templateId']}"
        delete_response = requests.delete(delete_url, headers=headers)

        if delete_response.status_code in [200, 204]:
            print(f"✓ Deleted: {template.get('name', 'Unknown')}")
            deleted_count += 1
        else:
            print(f"✗ Failed: {template.get('name', 'Unknown')}")

    print(f"\nDeleted {deleted_count} out of {len(deprecated_templates)} deprecated templates")

# Example usage - dry run first
delete_deprecated_templates("YOUR_API_KEY", dry_run=True)

# Then execute for real
# delete_deprecated_templates("YOUR_API_KEY", dry_run=False)

​
3. Delete Templates by Language

Delete all templates for a specific language: 
async function deleteTemplatesByLanguage(language, apiKey, confirmAll = false) {
  const headers = { 'Authorization': `${apiKey}` };

  // Get all templates
  const listResponse = await fetch(
    'https://api.pictory.ai/pictoryapis/v1/templates',
    { headers }
  );
  const data = await listResponse.json();

  // Filter by language
  const matchingTemplates = data.items.filter(t => t.language === language);

  console.log(`Found ${matchingTemplates.length} templates with language: ${language}`);

  if (!confirmAll) {
    console.log('Set confirmAll=true to delete these templates');
    matchingTemplates.forEach(t => {
      console.log(`  - ${t.name} (${t.templateId})`);
    });
    return matchingTemplates;
  }

  // Delete matching templates
  const results = {
    deleted: [],
    failed: []
  };

  for (const template of matchingTemplates) {
    const deleteResponse = await fetch(
      `https://api.pictory.ai/pictoryapis/v1/templates/${template.templateId}`,
      { method: 'DELETE', headers }
    );

    if (deleteResponse.status === 200 || deleteResponse.status === 204) {
      results.deleted.push(template.name);
      console.log(`✓ Deleted: ${template.name}`);
    } else {
      results.failed.push(template.name);
      console.log(`✗ Failed: ${template.name}`);
    }
  }

  console.log(`\nDeleted: ${results.deleted.length}, Failed: ${results.failed.length}`);
  return results;
}

// Example usage
const results = await deleteTemplatesByLanguage('en', 'YOUR_API_KEY', false);

​
4. Back Up Before Delete

Back up template configuration before deletion: 
import requests
import json
import os
from datetime import datetime

def backup_and_delete_template(template_id, api_key, backup_dir="./template_backups"):
    """
    Backup template configuration before deleting
    """
    headers = {"Authorization": api_key}

    # Get template details
    get_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    response = requests.get(get_url, headers=headers)

    if response.status_code != 200:
        print("Template not found")
        return False

    template = response.json()
    template_name = template.get('name', template_id)

    # Create backup directory
    os.makedirs(backup_dir, exist_ok=True)

    # Save template configuration
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{template_name.replace(' ', '_')}_{template_id}_{timestamp}.json"
    filepath = os.path.join(backup_dir, filename)

    backup_data = {
        "deletedDate": datetime.now().isoformat(),
        "templateData": template
    }

    with open(filepath, 'w') as f:
        json.dump(backup_data, f, indent=2)

    print(f"Backup saved to: {filepath}")

    # Delete template
    print(f"Deleting template...")
    delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"
    delete_response = requests.delete(delete_url, headers=headers)

    if delete_response.status_code in [200, 204]:
        print(f"Template '{template_name}' deleted successfully")
        return True
    else:
        print(f"Failed to delete template")
        return False

# Example usage
backup_and_delete_template("YOUR_TEMPLATE_ID", "YOUR_API_KEY")

​
5. Safe Delete with Retry Logic

Delete template with error handling and retry: 
async function safeDeleteTemplate(templateId, apiKey, maxRetries = 3) {
  const headers = { 'Authorization': `${apiKey}` };

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`Attempt ${attempt} to delete template ${templateId}...`);

      const response = await fetch(
        `https://api.pictory.ai/pictoryapis/v1/templates/${templateId}`,
        { method: 'DELETE', headers }
      );

      if (response.status === 401) {
        throw new Error('Unauthorized - check your API key');
      }

      if (response.status === 404) {
        console.log('Template already deleted or does not exist');
        return { success: true, message: 'Template not found' };
      }

      if (response.status === 200 || response.status === 204) {
        console.log('Template deleted successfully');
        return { success: true };
      }

      const result = await response.json().catch(() => ({}));

      if (attempt < maxRetries) {
        console.log(`Deletion failed, retrying in ${attempt * 2} seconds...`);
        await new Promise(resolve => setTimeout(resolve, attempt * 2000));
      }
    } catch (error) {
      console.error(`Error on attempt ${attempt}:`, error.message);

      if (attempt === maxRetries) {
        throw error;
      }

      await new Promise(resolve => setTimeout(resolve, attempt * 2000));
    }
  }

  throw new Error(`Failed to delete template after ${maxRetries} attempts`);
}

// Example usage
try {
  const result = await safeDeleteTemplate('YOUR_TEMPLATE_ID', 'YOUR_API_KEY');
  console.log('Result:', result);
} catch (error) {
  console.error('Final error:', error.message);
}

​
6. Delete Unpublished Draft Templates

Delete all unpublished draft templates: 
import requests

def delete_unpublished_templates(api_key, confirm=False):
    """
    Delete all unpublished (draft) templates
    """
    headers = {"Authorization": api_key}

    # Get all templates
    list_url = "https://api.pictory.ai/pictoryapis/v1/templates"
    response = requests.get(list_url, headers=headers)
    templates = response.json().get('items', [])

    # Find unpublished templates
    unpublished = [t for t in templates if not t.get('published')]

    print(f"Found {len(unpublished)} unpublished templates")

    if not unpublished:
        print("No unpublished templates to delete")
        return

    # List templates
    for i, template in enumerate(unpublished, 1):
        print(f"{i}. {template.get('name', 'Unknown')} (ID: {template['templateId']})")

    if not confirm:
        print("\nSet confirm=True to delete these templates")
        return

    # Delete templates
    deleted_count = 0
    for template in unpublished:
        delete_url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template['templateId']}"
        delete_response = requests.delete(delete_url, headers=headers)

        if delete_response.status_code in [200, 204]:
            print(f"✓ Deleted: {template.get('name', 'Unknown')}")
            deleted_count += 1
        else:
            print(f"✗ Failed: {template.get('name', 'Unknown')}")

    print(f"\nDeleted {deleted_count} out of {len(unpublished)} unpublished templates")

# Example usage
delete_unpublished_templates("YOUR_API_KEY", confirm=False)

​
Best Practices

​
Safety Measures

  1. Always back up before deletion: Use the Get Template By Id endpoint to retrieve the complete configuration before deleting
  2. Implement confirmation: Require user confirmation before executing delete operations
  3. Use dry runs: Test deletion logic with dry run mode before executing
  4. Log deletions: Keep audit logs of deleted templates for accountability
  5. Handle errors gracefully: Implement proper error handling and retry logic

​
Common Pitfalls

  • ❌ No Backup: Deleting without backing up the template configuration
  • ❌ Bulk Operations: Deleting multiple templates without confirmation
  • ❌ Production Testing: Testing deletion on production templates
  • ❌ Ignoring Errors: Not checking response status codes

​
Bulk Operations

When deleting multiple templates:
  • Add delays between deletions to avoid rate limiting
  • Process deletions in batches
  • Implement comprehensive error handling
  • Provide progress updates to users
  • Log both successes and failures

​
Recovery Planning

Since deletion is permanent:
  • Maintain regular backups of template configurations
  • Export template data before deletion
  • Keep deletion logs for audit trails
  • Store template JSON files for potential recreation