Get Storyboard Preview Job by ID

curl --request GET \
  --url 'https://api.pictory.ai/pictoryapis/v1/jobs/a1d36612-326d-4b81-aece-411f8aed4c70' \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'accept: application/json' | python -m json.tool

import requests
import time

def poll_storyboard_job(api_key, job_id, max_wait=600, poll_interval=15):
    """
    Poll for storyboard preview job completion.

    Args:
        api_key: Your Pictory API key
        job_id: The storyboard preview job ID
        max_wait: Maximum wait time in seconds (default 10 minutes)
        poll_interval: Polling interval in seconds (default 15 seconds)
    """
    url = f"https://api.pictory.ai/pictoryapis/v1/jobs/{job_id}"
    headers = {
        "Authorization": api_key,
        "accept": "application/json"
    }

    start_time = time.time()

    while time.time() - start_time < max_wait:
        response = requests.get(url, headers=headers)
        data = response.json()

        if not data.get("success"):
            print("Job failed")
            return data

        status = data.get("data", {}).get("status")

        if status == "in-progress":
            print(f"Storyboard generation in progress... (elapsed: {int(time.time() - start_time)}s)")
            time.sleep(poll_interval)
            continue

        if status == "completed":
            job_data = data["data"]
            print("Storyboard preview ready!")
            print(f"Preview URL: {job_data.get('previewUrl')}")
            print(f"Scenes: {len(job_data.get('storyboard', {}).get('scenes', []))}")
            return data

        # Unknown status
        print(f"Unexpected status: {status}")
        return data

    print("Timeout waiting for storyboard preview")
    return None

# Usage
result = poll_storyboard_job("YOUR_API_KEY", "a1d36612-326d-4b81-aece-411f8aed4c70")

if result and result.get("success"):
    data = result["data"]

    # Access the preview URL
    preview_url = data.get("previewUrl")
    print(f"Preview: {preview_url}")

    # Access renderParams for customization
    render_params = data.get("renderParams")

    # Access processed storyboard for re-submission
    storyboard = data.get("storyboard")

const jobId = 'a1d36612-326d-4b81-aece-411f8aed4c70';

async function pollStoryboardJob(apiKey, jobId, maxWait = 600000, pollInterval = 15000) {
  const url = `https://api.pictory.ai/pictoryapis/v1/jobs/${jobId}`;
  const startTime = Date.now();

  while (Date.now() - startTime < maxWait) {
    const response = await fetch(url, {
      method: 'GET',
      headers: {
        'Authorization': apiKey,
        'accept': 'application/json'
      }
    });

    const data = await response.json();

    if (!data.success) {
      console.log('Job failed');
      return data;
    }

    const status = data.data?.status;

    if (status === 'in-progress') {
      console.log(`Storyboard generation in progress... (${Math.round((Date.now() - startTime) / 1000)}s)`);
      await new Promise(resolve => setTimeout(resolve, pollInterval));
      continue;
    }

    if (status === 'completed') {
      console.log('Storyboard preview ready!');
      console.log(`Preview URL: ${data.data.previewUrl}`);
      console.log(`Scenes: ${data.data.storyboard?.scenes?.length}`);
      return data;
    }

    console.log(`Unexpected status: ${status}`);
    return data;
  }

  console.log('Timeout waiting for storyboard preview');
  return null;
}

// Usage
const result = await pollStoryboardJob('YOUR_API_KEY', jobId);

if (result?.success) {
  const { previewUrl, renderParams, storyboard } = result.data;
  console.log(`Preview: ${previewUrl}`);
}

<?php
function pollStoryboardJob($apiKey, $jobId, $maxWait = 600, $pollInterval = 15) {
    $url = "https://api.pictory.ai/pictoryapis/v1/jobs/{$jobId}";
    $startTime = time();

    while (time() - $startTime < $maxWait) {
        $ch = curl_init($url);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: ' . $apiKey,
            'accept: application/json'
        ]);

        $response = curl_exec($ch);
        curl_close($ch);

        $data = json_decode($response, true);

        if (!$data['success']) {
            echo "Job failed\n";
            return $data;
        }

        $status = $data['data']['status'] ?? null;

        if ($status === 'in-progress') {
            $elapsed = time() - $startTime;
            echo "Storyboard generation in progress... ({$elapsed}s)\n";
            sleep($pollInterval);
            continue;
        }

        if ($status === 'completed') {
            echo "Storyboard preview ready!\n";
            echo "Preview URL: " . ($data['data']['previewUrl'] ?? '') . "\n";
            echo "Scenes: " . count($data['data']['storyboard']['scenes'] ?? []) . "\n";
            return $data;
        }

        echo "Unexpected status: {$status}\n";
        return $data;
    }

    echo "Timeout waiting for storyboard preview\n";
    return null;
}

// Usage
$result = pollStoryboardJob('YOUR_API_KEY', 'a1d36612-326d-4b81-aece-411f8aed4c70');

if ($result && $result['success']) {
    $previewUrl = $result['data']['previewUrl'] ?? '';
    echo "Preview: {$previewUrl}\n";
}
?>

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "time"
)

func pollStoryboardJob(apiKey, jobID string, maxWait, pollInterval time.Duration) (map[string]interface{}, error) {
    url := fmt.Sprintf("https://api.pictory.ai/pictoryapis/v1/jobs/%s", jobID)
    startTime := time.Now()

    for time.Since(startTime) < maxWait {
        req, _ := http.NewRequest("GET", url, nil)
        req.Header.Set("Authorization", apiKey)
        req.Header.Set("accept", "application/json")

        client := &http.Client{}
        resp, err := client.Do(req)
        if err != nil {
            return nil, err
        }

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

        var data map[string]interface{}
        json.Unmarshal(body, &data)

        success, _ := data["success"].(bool)
        if !success {
            fmt.Println("Job failed")
            return data, nil
        }

        jobData, _ := data["data"].(map[string]interface{})
        status, _ := jobData["status"].(string)

        if status == "in-progress" {
            elapsed := int(time.Since(startTime).Seconds())
            fmt.Printf("Storyboard generation in progress... (%ds)\n", elapsed)
            time.Sleep(pollInterval)
            continue
        }

        if status == "completed" {
            fmt.Println("Storyboard preview ready!")
            if previewUrl, ok := jobData["previewUrl"].(string); ok {
                fmt.Printf("Preview URL: %s\n", previewUrl)
            }
            return data, nil
        }

        fmt.Printf("Unexpected status: %s\n", status)
        return data, nil
    }

    return nil, fmt.Errorf("timeout waiting for storyboard preview")
}

func main() {
    result, err := pollStoryboardJob(
        "YOUR_API_KEY",
        "a1d36612-326d-4b81-aece-411f8aed4c70",
        10*time.Minute,
        15*time.Second,
    )
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    if success, ok := result["success"].(bool); ok && success {
        data := result["data"].(map[string]interface{})
        if previewUrl, ok := data["previewUrl"].(string); ok {
            fmt.Printf("Preview: %s\n", previewUrl)
        }
    }
}