Video Summary

POST https://api.pictory.ai/pictoryapis/v2/transcription/highlights

import requests

def create_social_media_summary(full_transcript, api_key):
    """
    Generate a 30-second highlight reel for social media
    """
    url = "https://api.pictory.ai/pictoryapis/v2/transcription/highlights"
    headers = {
        "Authorization": api_key,
        "Content-Type": "application/json"
    }

    payload = {
        "transcript": full_transcript,
        "highlight_duration": 30,  # Perfect for Instagram/TikTok
        "webhook": "https://your-domain.com/webhooks/social-summary"
    }

    response = requests.post(url, json=payload, headers=headers)
    data = response.json()

    if data.get("success"):
        print(f"Social media summary job created: {data['data']['jobId']}")
        return data['data']['jobId']
    else:
        print(f"Failed to create summary: {data.get('message')}")
        return None

# Example usage
transcript = [
    {"text": "In today's video, we're diving deep into AI technology.", "start": 0, "end": 5},
    {"text": "This breakthrough will change everything.", "start": 5, "end": 9},
    {"text": "Let me show you the three key features.", "start": 9, "end": 13},
    # ... more segments
]

job_id = create_social_media_summary(transcript, "YOUR_API_KEY")

async function batchProcessSummaries(videos, apiKey, targetDuration) {
  const results = [];

  for (const video of videos) {
    try {
      const response = await fetch(
        'https://api.pictory.ai/pictoryapis/v2/transcription/highlights',
        {
          method: 'POST',
          headers: {
            'Authorization': `${apiKey}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            transcript: video.transcript,
            highlight_duration: targetDuration,
            webhook: `https://your-domain.com/webhooks/${video.id}`
          })
        }
      );

      const data = await response.json();

      if (data.success) {
        results.push({
          videoId: video.id,
          jobId: data.data.jobId,
          status: 'submitted'
        });
        console.log(`✓ ${video.title}: Job ${data.data.jobId}`);
      } else {
        results.push({
          videoId: video.id,
          status: 'failed',
          error: data.message
        });
        console.log(`✗ ${video.title}: Failed`);
      }
    } catch (error) {
      console.error(`Error processing ${video.title}:`, error.message);
      results.push({
        videoId: video.id,
        status: 'error',
        error: error.message
      });
    }

    // Add small delay to avoid rate limiting
    await new Promise(resolve => setTimeout(resolve, 100));
  }

  console.log(`\nProcessed ${results.length} videos`);
  console.log(`Successful: ${results.filter(r => r.status === 'submitted').length}`);
  console.log(`Failed: ${results.filter(r => r.status !== 'submitted').length}`);

  return results;
}

// Example usage
const videos = [
  {
    id: 'video-1',
    title: 'Product Demo',
    transcript: [/* transcript data */]
  },
  {
    id: 'video-2',
    title: 'Tutorial',
    transcript: [/* transcript data */]
  }
];

const results = await batchProcessSummaries(videos, 'YOUR_API_KEY', 60);

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

@app.route('/webhooks/video-summary', methods=['POST'])
def handle_summary_webhook():
    """
    Receive and process completed video summary
    """
    try:
        summary_data = request.json

        # Log the received data
        print(f"Received summary for job: {summary_data.get('jobId')}")

        # Process the summary
        # (The exact structure depends on what Pictory sends)
        job_id = summary_data.get('jobId')
        highlights = summary_data.get('highlights', [])

        # Save to database, trigger next step, etc.
        save_summary_to_database(job_id, highlights)

        # Optionally trigger video creation with the highlights
        create_video_from_highlights(highlights)

        return jsonify({"status": "success"}), 200

    except Exception as e:
        print(f"Error processing webhook: {str(e)}")
        return jsonify({"status": "error", "message": str(e)}), 500

def save_summary_to_database(job_id, highlights):
    # Your database logic here
    pass

def create_video_from_highlights(highlights):
    # Create a video project using the highlights
    pass

if __name__ == '__main__':
    app.run(port=3000)

def create_multi_duration_summaries(transcript, api_key):
    """
    Create summaries of different durations for various platforms
    """
    durations = {
        'tiktok': 15,      # TikTok/Reels
        'instagram': 30,   # Instagram feed
        'twitter': 45,     # Twitter/X
        'youtube': 60      # YouTube Shorts
    }

    jobs = {}

    for platform, duration in durations.items():
        response = requests.post(
            "https://api.pictory.ai/pictoryapis/v2/transcription/highlights",
            json={
                "transcript": transcript,
                "highlight_duration": duration,
                "webhook": f"https://your-domain.com/webhooks/{platform}"
            },
            headers={
                "Authorization": api_key,
                "Content-Type": "application/json"
            }
        )

        data = response.json()

        if data.get("success"):
            jobs[platform] = {
                'job_id': data['data']['jobId'],
                'duration': duration,
                'status': 'processing'
            }
            print(f"✓ {platform.title()}: {duration}s summary (Job: {data['data']['jobId']})")
        else:
            print(f"✗ {platform.title()}: Failed")

    return jobs

# Example usage
full_transcript = [
    {"text": "Welcome to today's product update.", "start": 0, "end": 3},
    {"text": "We've added three exciting new features.", "start": 3, "end": 7},
    # ... more transcript segments
]

summary_jobs = create_multi_duration_summaries(full_transcript, "YOUR_API_KEY")
print(f"\nCreated {len(summary_jobs)} summary jobs")

function validateTranscript(transcript) {
  const errors = [];

  if (!Array.isArray(transcript) || transcript.length === 0) {
    errors.push('Transcript must be a non-empty array');
    return { valid: false, errors };
  }

  // Check each segment
  transcript.forEach((segment, index) => {
    if (!segment.text || segment.text.trim() === '') {
      errors.push(`Segment ${index}: Missing or empty text`);
    }

    if (typeof segment.start !== 'number' || segment.start < 0) {
      errors.push(`Segment ${index}: Invalid start time`);
    }

    if (typeof segment.end !== 'number' || segment.end <= segment.start) {
      errors.push(`Segment ${index}: End time must be greater than start time`);
    }
  });

  // Check chronological order
  for (let i = 1; i < transcript.length; i++) {
    if (transcript[i].start < transcript[i-1].end) {
      errors.push(`Segment ${i}: Overlaps with previous segment`);
    }
  }

  // Calculate total duration
  const totalDuration = transcript[transcript.length - 1].end - transcript[0].start;

  return {
    valid: errors.length === 0,
    errors,
    totalDuration,
    segmentCount: transcript.length
  };
}

async function generateSummaryWithValidation(transcript, duration, apiKey) {
  // Validate transcript
  const validation = validateTranscript(transcript);

  if (!validation.valid) {
    console.error('Transcript validation failed:');
    validation.errors.forEach(error => console.error(`  - ${error}`));
    return null;
  }

  console.log(`Transcript valid:`);
  console.log(`  - ${validation.segmentCount} segments`);
  console.log(`  - ${validation.totalDuration.toFixed(1)}s total duration`);

  // Check if requested duration is reasonable
  if (duration > validation.totalDuration) {
    console.warn(`Warning: Requested duration (${duration}s) exceeds transcript duration (${validation.totalDuration.toFixed(1)}s)`);
  }

  // Generate summary
  const response = await fetch(
    'https://api.pictory.ai/pictoryapis/v2/transcription/highlights',
    {
      method: 'POST',
      headers: {
        'Authorization': `${apiKey}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        transcript,
        highlight_duration: duration
      })
    }
  );

  const data = await response.json();

  if (data.success) {
    console.log(`✓ Summary job created: ${data.data.jobId}`);
    return data.data.jobId;
  } else {
    console.error(`✗ Failed to create summary: ${data.message}`);
    return null;
  }
}

// Example usage
const transcript = [
  { text: "Introduction to the topic.", start: 0, end: 5 },
  { text: "Main content section one.", start: 5, end: 15 },
  { text: "Main content section two.", start: 15, end: 25 }
];

const jobId = await generateSummaryWithValidation(transcript, 15, 'YOUR_API_KEY');