Video Processing Guide

# Check processing status
curl "https://api.rixl.com/videos/{videoId}" \
-H "X-API-Key: YOUR_API_KEY"

/**
* Video upload with TypeScript and comprehensive error handling
*/

interface VideoUploadOptions {
file_name: string;
video_quality: 'basic' | 'shorts' | 'pro';
image_format: 'jpg' | 'png' | 'webp';
}

interface UploadResponse {
video_id: string;
video_presigned_url: string;
expires_at: string;
}

async function uploadVideo(
videoFile: File,
apiKey: string,
options: VideoUploadOptions
): Promise
<string> {
  try {
  // Step 1: Initialize upload
  const initResponse = await fetch('https://api.rixl.com/videos/upload/init', {
  method: 'POST',
  headers: {
  'X-API-Key': apiKey,
  'Content-Type': 'application/json',
  'Accept': 'application/json'
},
  body: JSON.stringify(options)
});

  if (!initResponse.ok) {
  const errorData = await initResponse.json().catch(() => ({}));
  throw new Error(`Upload initialization failed: ${errorData.message || initResponse.statusText}`);
}

  const uploadData: UploadResponse = await initResponse.json();

  // Step 2: Upload video file
  const videoUpload = await fetch(uploadData.video_presigned_url, {
  method: 'PUT',
  body: videoFile,
  headers: {
  'Content-Type': videoFile.type || 'video/mp4'
}
});

  if (!videoUpload.ok) {
  throw new Error(`Video upload failed: ${videoUpload.statusText}`);
}

  // Step 3: Complete upload
  const completeResponse = await fetch(
  `https://api.rixl.com/videos/${uploadData.video_id}/upload/complete/`,
{
  method: 'POST',
  headers: {
  'X-API-Key': apiKey,
  'Content-Type': 'application/json'
}
}
  );

  if (!completeResponse.ok) {
  const errorData = await completeResponse.json().catch(() => ({}));
  throw new Error(`Upload completion failed: ${errorData.message || completeResponse.statusText}`);
}

  console.log('Video processing started successfully!');
  return uploadData.video_id;

} catch (error) {
  console.error('Upload failed:', error);
  throw error;
}
}

  // Usage example
  const handleUpload = async (file: File) => {
    const videoId = await uploadVideo(file, 'YOUR_PROJECT_API_KEY', {
    file_name: file.name,
    video_quality: 'pro',
    image_format: 'jpg'
  });

    console.log(`Upload successful! Video ID: ${videoId}`);
  };

"""
Modern Python video upload with proper error handling and type hints
"""

import requests
from typing import Dict, Any
from pathlib import Path
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class VideoUploadError(Exception):
"""Custom exception for video upload errors"""
pass

def upload_video(
file_path: Path,
api_key: str,
video_quality: str = 'pro',
image_format: str = 'jpg'
) -> str:
"""
Upload a video file to RIXL platform.

Args:
file_path: Path to the video file
api_key: Your RIXL project API key
video_quality: Quality tier ('basic', 'shorts', 'pro')
image_format: Thumbnail format ('jpg', 'png', 'webp')

Returns:
str: Video ID of the uploaded video

Raises:
VideoUploadError: If any step fails
"""

if not file_path.exists():
raise VideoUploadError(f"Video file not found: {file_path}")

session = requests.Session()
session.headers.update({
'X-API-Key': api_key,
'User-Agent': 'RIXL-Python-Client/1.0'
})

try:
# Step 1: Initialize upload
logger.info(f"Initializing upload for {file_path.name}")

init_response = session.post(
'https://api.rixl.com/videos/upload/init',
json={
'file_name': file_path.name,
'video_quality': video_quality,
'image_format': image_format
},
timeout=30
)

init_response.raise_for_status()
upload_data = init_response.json()

# Step 2: Upload video file
logger.info(" Uploading video file...")

with open(file_path, 'rb') as video_file:
upload_response = session.put(
upload_data['video_presigned_url'],
data=video_file,
headers={'Content-Type': 'video/mp4'},
timeout=300
)

upload_response.raise_for_status()

# Step 3: Complete upload
logger.info("Completing upload...")

complete_response = session.post(
f"https://api.rixl.com/videos/{upload_data['video_id']}/upload/complete/",
timeout=30
)

complete_response.raise_for_status()

video_id = upload_data['video_id']
logger.info(f"Upload successful! Video ID: {video_id}")

return video_id

except requests.exceptions.HTTPError as e:
error_msg = f"HTTP error: {e.response.status_code}"
if e.response.content:
try:
error_data = e.response.json()
error_msg += f" - {error_data.get('message', 'Unknown error')}"
except ValueError:
pass
raise VideoUploadError(error_msg) from e

except requests.exceptions.RequestException as e:
raise VideoUploadError(f"Network error: {str(e)}") from e

# Usage example
if __name__ == "__main__":
try:
video_id = upload_video(
file_path=Path("my-video.mp4"),
api_key="YOUR_PROJECT_API_KEY",
video_quality="pro"
)
print(f"Success! Video ID: {video_id}")

except VideoUploadError as e:
logger.error(f"Upload failed: {e}")

# 1. Initialize upload
curl -X POST https://api.rixl.com/videos/upload/init \
-H "X-API-Key: YOUR_PROJECT_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"file_name": "my-video.mp4",
"video_quality": "pro",
"image_format": "jpg"
}'

# 2. Upload video (using presigned URL from response)
curl -X PUT "$VIDEO_PRESIGNED_URL" \
--upload-file my-video.mp4 \
-H "Content-Type: video/mp4"

# 3. Complete upload
curl -X POST https://api.rixl.com/videos/upload/complete/$VIDEO_ID \
-H "X-API-Key: YOUR_PROJECT_API_KEY"