Get Video Render Job by ID

curl --request GET \
  --url 'https://api.pictory.ai/pictoryapis/v1/jobs/265a7c1a-4985-4058-9208-68114f131a2b' \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'accept: application/json' | python -m json.tool

import requests
import time

def poll_render_job(api_key, job_id, max_wait=900, poll_interval=15):
    """
    Poll for video render job completion.

    Args:
        api_key: Your Pictory API key
        job_id: The render job ID
        max_wait: Maximum wait time in seconds (default 15 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"):
            error_data = data.get("data", {})
            print(f"Job failed: {error_data.get('error_message', 'Unknown error')}")
            return data

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

        if status == "in-progress":
            progress = data["data"].get("renderProgress", 0)
            message = data["data"].get("renderProgressMessage", "Processing")
            print(f"Rendering... {progress}% - {message}")
            time.sleep(poll_interval)
            continue

        if status == "completed":
            result = data["data"]
            print(f"Render complete!")
            print(f"Video URL: {result.get('videoURL')}")
            print(f"Duration: {result.get('videoDuration')}s")
            print(f"Encoding time: {result.get('encodingDuration')}s")
            return data

        if status == "failed":
            error_msg = data["data"].get("error_message", "Unknown error")
            print(f"Render failed: {error_msg}")
            return data

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

    print("Timeout waiting for render")
    return None

# Usage
result = poll_render_job("YOUR_API_KEY", "265a7c1a-4985-4058-9208-68114f131a2b")

if result and result.get("success") and result["data"].get("status") == "completed":
    data = result["data"]
    print(f"\nVideo: {data['videoURL']}")
    print(f"Share: {data['videoShareURL']}")
    print(f"Thumbnail: {data['thumbnail']}")
    print(f"SRT: {data['srtFile']}")

const jobId = '265a7c1a-4985-4058-9208-68114f131a2b';

async function pollRenderJob(apiKey, jobId, maxWait = 900000, 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: ${data.data?.error_message || 'Unknown error'}`);
      return data;
    }

    const status = data.data?.status;

    if (status === 'in-progress') {
      const progress = data.data?.renderProgress || 0;
      const message = data.data?.renderProgressMessage || 'Processing';
      console.log(`Rendering... ${progress}% - ${message}`);
      await new Promise(resolve => setTimeout(resolve, pollInterval));
      continue;
    }

    if (status === 'completed') {
      console.log('Render complete!');
      console.log(`Video URL: ${data.data.videoURL}`);
      console.log(`Duration: ${data.data.videoDuration}s`);
      return data;
    }

    if (status === 'failed') {
      console.log(`Render failed: ${data.data?.error_message}`);
      return data;
    }

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

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

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

if (result?.success && result.data?.status === 'completed') {
  console.log(`\nVideo: ${result.data.videoURL}`);
  console.log(`Share: ${result.data.videoShareURL}`);
}

<?php
function pollRenderJob($apiKey, $jobId, $maxWait = 900, $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: " . ($data['data']['error_message'] ?? 'Unknown error') . "\n";
            return $data;
        }

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

        if ($status === 'in-progress') {
            $progress = $data['data']['renderProgress'] ?? 0;
            $message = $data['data']['renderProgressMessage'] ?? 'Processing';
            echo "Rendering... {$progress}% - {$message}\n";
            sleep($pollInterval);
            continue;
        }

        if ($status === 'completed') {
            echo "Render complete!\n";
            echo "Video URL: " . ($data['data']['videoURL'] ?? '') . "\n";
            echo "Duration: " . ($data['data']['videoDuration'] ?? 0) . "s\n";
            return $data;
        }

        if ($status === 'failed') {
            echo "Render failed: " . ($data['data']['error_message'] ?? 'Unknown error') . "\n";
            return $data;
        }

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

    echo "Timeout waiting for render\n";
    return null;
}

// Usage
$result = pollRenderJob('YOUR_API_KEY', '265a7c1a-4985-4058-9208-68114f131a2b');

if ($result && $result['success'] && ($result['data']['status'] ?? '') === 'completed') {
    echo "\nVideo: " . $result['data']['videoURL'] . "\n";
    echo "Share: " . $result['data']['videoShareURL'] . "\n";
}
?>

package main

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

func pollRenderJob(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" {
            progress, _ := jobData["renderProgress"].(float64)
            fmt.Printf("Rendering... %.0f%%\n", progress)
            time.Sleep(pollInterval)
            continue
        }

        if status == "completed" {
            fmt.Println("Render complete!")
            if videoURL, ok := jobData["videoURL"].(string); ok {
                fmt.Printf("Video URL: %s\n", videoURL)
            }
            return data, nil
        }

        if status == "failed" {
            if msg, ok := jobData["error_message"].(string); ok {
                fmt.Printf("Render failed: %s\n", msg)
            }
            return data, nil
        }

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

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

func main() {
    result, err := pollRenderJob(
        "YOUR_API_KEY",
        "265a7c1a-4985-4058-9208-68114f131a2b",
        15*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 videoURL, ok := data["videoURL"].(string); ok {
            fmt.Printf("\nVideo: %s\n", videoURL)
        }
    }
}