Delete Template

curl --request DELETE \
  --url https://api.pictory.ai/pictoryapis/v1/templates/{templateId} \
  --header 'Authorization: <authorization>'

import requests

url = "https://api.pictory.ai/pictoryapis/v1/templates/{templateId}"

headers = {"Authorization": "<authorization>"}

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

print(response.text)

const options = {method: 'DELETE', headers: {Authorization: '<authorization>'}};

fetch('https://api.pictory.ai/pictoryapis/v1/templates/{templateId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pictory.ai/pictoryapis/v1/templates/{templateId}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.pictory.ai/pictoryapis/v1/templates/{templateId}"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.pictory.ai/pictoryapis/v1/templates/{templateId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body

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

// Empty response body (successful deletion)

{
  "message": "Unauthorized"
}

{
  "success": false,
  "message": "Template not found"
}

{
  "success": false,
  "message": "You do not have permission to delete this template"
}

DELETE

pictoryapis

templates

{templateId}

Delete Template

curl --request DELETE \
  --url https://api.pictory.ai/pictoryapis/v1/templates/{templateId} \
  --header 'Authorization: <authorization>'

import requests

url = "https://api.pictory.ai/pictoryapis/v1/templates/{templateId}"

headers = {"Authorization": "<authorization>"}

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

print(response.text)

const options = {method: 'DELETE', headers: {Authorization: '<authorization>'}};

fetch('https://api.pictory.ai/pictoryapis/v1/templates/{templateId}', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pictory.ai/pictoryapis/v1/templates/{templateId}",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "Authorization: <authorization>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.pictory.ai/pictoryapis/v1/templates/{templateId}"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("Authorization", "<authorization>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

require 'uri'
require 'net/http'

url = URI("https://api.pictory.ai/pictoryapis/v1/templates/{templateId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body

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

// Empty response body (successful deletion)

{
  "message": "Unauthorized"
}

{
  "success": false,
  "message": "Template not found"
}

{
  "success": false,
  "message": "You do not have permission to delete this template"
}

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

string

required

The unique identifier of the template to deleteExample: 202512230204424435786014d42904bbc95813430789fe736

Headers

string

required

API key for authentication (starts with pictai_)

Authorization: YOUR_API_KEY

Response

boolean

Indicates whether the deletion was successful

string

Confirmation message about the deletion

Response Examples

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

// Empty response body (successful deletion)

{
  "message": "Unauthorized"
}

{
  "success": false,
  "message": "Template not found"
}

{
  "success": false,
  "message": "You do not have permission to delete this template"
}

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

import requests

template_id = "202512230204424435786014d42904bbc95813430789fe736"
url = f"https://api.pictory.ai/pictoryapis/v1/templates/{template_id}"

headers = {
    "Authorization": "YOUR_API_KEY",
    "accept": "application/json"
}

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

if response.status_code in [200, 204]:
    print(f"Template {template_id} deleted successfully")
else:
    try:
        result = response.json()
        print(f"Failed to delete template: {result.get('message', 'Unknown error')}")
    except:
        print(f"Failed to delete template: HTTP {response.status_code}")

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

if (response.status === 200 || response.status === 204) {
  console.log(`Template ${templateId} deleted successfully`);
} else {
  const result = await response.json().catch(() => ({}));
  console.log(`Failed to delete template: ${result.message || 'Unknown error'}`);
}

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

Always back up before deletion: Use the Get Template By Id endpoint to retrieve the complete configuration before deleting
Implement confirmation: Require user confirmation before executing delete operations
Use dry runs: Test deletion logic with dry run mode before executing
Log deletions: Keep audit logs of deleted templates for accountability
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

Get Templates - List all available templates
Get Template By Id - Retrieve template details before deleting
Update Template - Modify template instead of deleting
Create Template - Create a new template

Getting started

Videos

Pictory Jobs

Video Storyboard

AI Studio

Smart Layouts

Avatars

VoiceOvers

Music Search

Media Management

Branding - Video

Pictory Projects

Video Templates

Video Summary and Transcription

Vimeo Integration

AWS Integration

Account & Usage

Delete Template

Overview

API Endpoint

Request Parameters

Path Parameters

Headers

Response

Response Examples

Code Examples

Usage Notes

Common Use Cases

1. Delete Single Template with Confirmation

2. Bulk Delete Deprecated Templates

3. Delete Templates by Language

4. Back Up Before Delete

5. Safe Delete with Retry Logic

6. Delete Unpublished Draft Templates

Best Practices

Safety Measures

Common Pitfalls

Bulk Operations

Recovery Planning

​Overview

​API Endpoint

​Request Parameters

​Path Parameters

​Headers

​Response

​Response Examples

​Code Examples

​Usage Notes

​Common Use Cases

​1. Delete Single Template with Confirmation

​2. Bulk Delete Deprecated Templates

​3. Delete Templates by Language

​4. Back Up Before Delete

​5. Safe Delete with Retry Logic

​6. Delete Unpublished Draft Templates

​Best Practices

​Safety Measures

​Common Pitfalls

​Bulk Operations

​Recovery Planning

​Related Endpoints

Overview

API Endpoint

Request Parameters

Path Parameters

Headers

Response

Response Examples

Code Examples

Usage Notes

Common Use Cases

1. Delete Single Template with Confirmation

2. Bulk Delete Deprecated Templates

3. Delete Templates by Language

4. Back Up Before Delete

5. Safe Delete with Retry Logic

6. Delete Unpublished Draft Templates

Best Practices

Safety Measures

Common Pitfalls

Bulk Operations

Recovery Planning

Related Endpoints