Transcription Workflow

import requests
import time
 
def wait_for_transcription(recording_id, api_key, timeout=600, interval=5):
    """
    Wait for transcription to complete.
 
    Args:
        recording_id: Recording ID to check
        api_key: API key for authentication
        timeout: Maximum wait time in seconds
        interval: Poll interval in seconds
 
    Returns:
        Recording data when complete
 
    Raises:
        TimeoutError: If transcription doesn't complete in time
        RuntimeError: If transcription fails
    """
    base_url = "https://api.identitycall.com/api/v1/public"
    headers = {"Authorization": f"Bearer {api_key}"}
 
    start_time = time.time()
 
    while True:
        response = requests.get(
            f"{base_url}/recordings/{recording_id}",
            headers=headers
        )
        recording = response.json()["data"]
        status = recording["status"]
 
        if status == "completed":
            return recording
 
        if status == "failed":
            raise RuntimeError("Transcription failed")
 
        if time.time() - start_time > timeout:
            raise TimeoutError("Transcription timed out")
 
        print(f"Status: {status}, waiting {interval}s...")
        time.sleep(interval)
 
 
# Usage
recording_id = 123
api_key = os.environ.get("IDENTITYCALL_API_KEY")
 
try:
    recording = wait_for_transcription(recording_id, api_key)
    print(f"Transcription complete! Duration: {recording['duration_ms']}ms")
except TimeoutError:
    print("Transcription is taking too long")
except RuntimeError as e:
    print(f"Error: {e}")

async function waitForTranscription(recordingId, apiKey, timeout = 600000, interval = 5000) {
  const baseUrl = 'https://api.identitycall.com/api/v1/public';
  const headers = { 'Authorization': `Bearer ${apiKey}` };
  const startTime = Date.now();
 
  while (true) {
    const response = await fetch(`${baseUrl}/recordings/${recordingId}`, { headers });
    const { data: recording } = await response.json();
    const status = recording.status;
 
    if (status === 'completed') {
      return recording;
    }
 
    if (status === 'failed') {
      throw new Error('Transcription failed');
    }
 
    if (Date.now() - startTime > timeout) {
      throw new Error('Transcription timed out');
    }
 
    console.log(`Status: ${status}, waiting ${interval / 1000}s...`);
    await new Promise(r => setTimeout(r, interval));
  }
}
 
// Usage
const recordingId = 123;
const apiKey = process.env.IDENTITYCALL_API_KEY;
 
try {
  const recording = await waitForTranscription(recordingId, apiKey);
  console.log(`Transcription complete! Duration: ${recording.duration_ms}ms`);
} catch (error) {
  console.error(`Error: ${error.message}`);
}

import requests
import os
import time
 
API_KEY = os.environ.get("IDENTITYCALL_API_KEY")
BASE_URL = "https://api.identitycall.com/api/v1/public"
 
def transcribe_audio(file_path, language="en"):
    """
    Complete workflow: upload, wait, and retrieve transcription.
    """
    headers = {"Authorization": f"Bearer {API_KEY}"}
 
    # Step 1: Upload
    print(f"Uploading {file_path}...")
    with open(file_path, "rb") as f:
        response = requests.post(
            f"{BASE_URL}/recordings",
            headers=headers,
            files={"file": f},
            data={"language": language}
        )
 
    if response.status_code != 201:
        raise Exception(f"Upload failed: {response.json()}")
 
    recording_id = response.json()["data"]["id"]
    print(f"Uploaded! Recording ID: {recording_id}")
 
    # Step 2: Wait for completion
    print("Processing...")
    start_time = time.time()
 
    while True:
        response = requests.get(
            f"{BASE_URL}/recordings/{recording_id}",
            headers=headers
        )
        status = response.json()["data"]["status"]
 
        if status == "completed":
            elapsed = time.time() - start_time
            print(f"Completed in {elapsed:.1f}s")
            break
        elif status == "failed":
            raise Exception("Transcription failed")
 
        time.sleep(5)
 
    # Step 3: Get transcription
    response = requests.get(
        f"{BASE_URL}/recordings/{recording_id}/transcription",
        headers=headers
    )
 
    return response.json()["data"]
 
 
# Usage
transcription = transcribe_audio("customer-call.mp3")
print(f"\nTranscript:\n{transcription['full_text']}")

const fs = require('fs');
const FormData = require('form-data');
 
const API_KEY = process.env.IDENTITYCALL_API_KEY;
const BASE_URL = 'https://api.identitycall.com/api/v1/public';
 
async function transcribeAudio(filePath, language = 'en') {
  const headers = { 'Authorization': `Bearer ${API_KEY}` };
 
  // Step 1: Upload
  console.log(`Uploading ${filePath}...`);
  const formData = new FormData();
  formData.append('file', fs.createReadStream(filePath));
  formData.append('language', language);
 
  const uploadResponse = await fetch(`${BASE_URL}/recordings`, {
    method: 'POST',
    headers,
    body: formData
  });
 
  if (!uploadResponse.ok) {
    throw new Error(`Upload failed: ${await uploadResponse.text()}`);
  }
 
  const { data: { id: recordingId } } = await uploadResponse.json();
  console.log(`Uploaded! Recording ID: ${recordingId}`);
 
  // Step 2: Wait for completion
  console.log('Processing...');
  const startTime = Date.now();
 
  while (true) {
    const statusResponse = await fetch(`${BASE_URL}/recordings/${recordingId}`, { headers });
    const { data: { status } } = await statusResponse.json();
 
    if (status === 'completed') {
      const elapsed = (Date.now() - startTime) / 1000;
      console.log(`Completed in ${elapsed.toFixed(1)}s`);
      break;
    } else if (status === 'failed') {
      throw new Error('Transcription failed');
    }
 
    await new Promise(r => setTimeout(r, 5000));
  }
 
  // Step 3: Get transcription
  const transcriptionResponse = await fetch(
    `${BASE_URL}/recordings/${recordingId}/transcription`,
    { headers }
  );
 
  return (await transcriptionResponse.json()).data;
}
 
// Usage
const transcription = await transcribeAudio('customer-call.mp3');
console.log(`\nTranscript:\n${transcription.full_text}`);