Get Transcription Job by ID

curl --request GET \
  --url 'https://api.pictory.ai/pictoryapis/v1/jobs/cbbc5305-3c1c-46f0-bdde-468e5ecd763f' \
  --header 'Authorization: YOUR_API_KEY' \
  --header 'accept: application/json' | python -m json.tool

import requests
import time

def poll_transcription_job(api_key, job_id, max_wait=600, poll_interval=15):
    """
    Poll for transcription job completion.

    Args:
        api_key: Your Pictory API key
        job_id: The transcription 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"Transcription in progress... (elapsed: {int(time.time() - start_time)}s)")
            time.sleep(poll_interval)
            continue

        # Job completed - transcript data is available
        transcript_data = data.get("data", {})
        print(f"Transcription complete!")
        print(f"Language: {transcript_data.get('language')}")
        print(f"Duration: {transcript_data.get('mediaInfo', {}).get('duration')}s")
        print(f"Segments: {len(transcript_data.get('transcript', []))}")
        return data

    print("Timeout waiting for transcription")
    return None

# Usage
result = poll_transcription_job("YOUR_API_KEY", "cbbc5305-3c1c-46f0-bdde-468e5ecd763f")

if result and result.get("success"):
    data = result["data"]
    # Access the plain text transcript
    print(f"\nTranscript:\n{data.get('txt', '')[:500]}...")

    # Access SRT subtitles
    srt = data.get("srt", "")
    print(f"\nSRT preview:\n{srt[:300]}...")

const jobId = 'cbbc5305-3c1c-46f0-bdde-468e5ecd763f';

async function pollTranscriptionJob(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(`Transcription in progress... (${Math.round((Date.now() - startTime) / 1000)}s)`);
      await new Promise(resolve => setTimeout(resolve, pollInterval));
      continue;
    }

    // Job completed
    console.log('Transcription complete!');
    console.log(`Language: ${data.data.language}`);
    console.log(`Duration: ${data.data.mediaInfo?.duration}s`);
    console.log(`Segments: ${data.data.transcript?.length}`);
    return data;
  }

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

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

if (result?.success) {
  console.log(`\nTranscript: ${result.data.txt?.substring(0, 500)}...`);
}

<?php
function pollTranscriptionJob($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 "Transcription in progress... ({$elapsed}s)\n";
            sleep($pollInterval);
            continue;
        }

        // Job completed
        echo "Transcription complete!\n";
        echo "Language: " . ($data['data']['language'] ?? 'unknown') . "\n";
        echo "Duration: " . ($data['data']['mediaInfo']['duration'] ?? 0) . "s\n";
        echo "Segments: " . count($data['data']['transcript'] ?? []) . "\n";
        return $data;
    }

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

// Usage
$result = pollTranscriptionJob('YOUR_API_KEY', 'cbbc5305-3c1c-46f0-bdde-468e5ecd763f');

if ($result && $result['success']) {
    echo "\nTranscript: " . substr($result['data']['txt'] ?? '', 0, 500) . "...\n";
}
?>

package main

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

func pollTranscriptionJob(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("Transcription in progress... (%ds)\n", elapsed)
            time.Sleep(pollInterval)
            continue
        }

        // Job completed
        fmt.Println("Transcription complete!")
        return data, nil
    }

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

func main() {
    result, err := pollTranscriptionJob(
        "YOUR_API_KEY",
        "cbbc5305-3c1c-46f0-bdde-468e5ecd763f",
        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 txt, ok := data["txt"].(string); ok {
            if len(txt) > 500 {
                txt = txt[:500] + "..."
            }
            fmt.Printf("\nTranscript: %s\n", txt)
        }
    }
}