Generate Video

{
  "success": true,
  "video_id": "operation_abc123",
  "video_url": "data:video/mp4;base64,AAAIGZ0...",
  "status": "completed",
  "prompt": "A cat jumping over a fence",
  "duration": 8
}

data:video/mp4;base64,AAAIGZ0dAA...

curl -X POST https://api.incredible.one/v1/generate-video \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A golden retriever playing in a sunny park"
  }'

import requests
import base64

response = requests.post(
    'https://api.incredible.one/v1/generate-video',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    json={
        'prompt': 'A cat jumping over a fence in slow motion',
        'size': '720x1280'  # Portrait for TikTok/Reels
    },
    timeout=660  # 11 minute timeout for generation
)

result = response.json()
if result['success']:
    # Extract base64 data
    video_data = result['video_url'].split(',')[1]
    
    # Save to file
    with open('generated_video.mp4', 'wb') as f:
        f.write(base64.b64decode(video_data))
    
    print("Video saved to generated_video.mp4")

import fs from 'fs';

// Read and encode reference image
const imageBuffer = fs.readFileSync('reference.png');
const imageBase64 = imageBuffer.toString('base64');

const response = await fetch('https://api.incredible.one/v1/generate-video', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    prompt: 'Animate this scene with gentle motion',
    input_reference: imageBase64,
    size: '1920x1080'
  })
});

const result = await response.json();

// Extract and save video
if (result.success) {
  const base64Data = result.video_url.split(',')[1];
  const videoBuffer = Buffer.from(base64Data, 'base64');
  fs.writeFileSync('animated_video.mp4', videoBuffer);
  console.log('Video saved!');
}

interface VideoGenerationRequest {
  prompt: string;
  size?: '1280x720' | '720x1280' | '1920x1080' | '1080x1920' | '1024x1024';
  input_reference?: string;
}

interface VideoGenerationResponse {
  success: boolean;
  video_id: string;
  video_url: string;
  status: string;
  prompt: string;
  duration: number;
}

async function generateVideo(
  prompt: string, 
  size: string = '1280x720'
): Promise<string> {
  const response = await fetch('https://api.incredible.one/v1/generate-video', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.INCREDIBLE_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ prompt, size })
  });

  const result: VideoGenerationResponse = await response.json();
  
  if (!result.success) {
    throw new Error('Video generation failed');
  }

  return result.video_url;
}

// Usage
const videoDataUri = await generateVideo(
  'A serene beach at sunset with waves',
  '1920x1080'
);

"A majestic eagle soaring over snowy mountain peaks at sunrise with 
cinematic camera movement"

"Slow motion shot of a coffee cup being filled, steam rising, 
warm morning light through window"

"Aerial drone footage flying through a dense forest with sunlight 
filtering through the canopy"

"Close-up of ocean waves crashing on rocks with dramatic slow motion 
and golden hour lighting"

import base64
import requests

# Read and encode your image
with open('reference.jpg', 'rb') as f:
    image_base64 = base64.b64encode(f.read()).decode('utf-8')

response = requests.post(
    'https://api.incredible.one/v1/generate-video',
    headers={'Authorization': 'Bearer YOUR_API_KEY'},
    json={
        'prompt': 'Add gentle motion and life to this scene',
        'input_reference': image_base64,
        'size': '1280x720'
    }
)

import requests

try:
    response = requests.post(
        'https://api.incredible.one/v1/generate-video',
        headers={'Authorization': 'Bearer YOUR_API_KEY'},
        json={'prompt': 'A beautiful landscape'},
        timeout=660
    )
    
    result = response.json()
    
    if result['success']:
        print(f"Video generated: {result['video_id']}")
        # Handle video data...
    else:
        print(f"Error: {result['error']}")
        if 'details' in result:
            print(f"Details: {result['details']}")
            
except requests.Timeout:
    print("Video generation timed out (>11 minutes)")
except Exception as e:
    print(f"Request failed: {str(e)}")

import base64

def save_video(video_url: str, filename: str):
    """Save base64 video data URI to file"""
    # Extract base64 data after the comma
    base64_data = video_url.split(',')[1]
    
    # Decode and write to file
    video_bytes = base64.b64decode(base64_data)
    with open(filename, 'wb') as f:
        f.write(video_bytes)

# Usage
result = response.json()
save_video(result['video_url'], 'output.mp4')

const fs = require('fs');

function saveVideo(videoUrl, filename) {
  // Extract base64 data
  const base64Data = videoUrl.split(',')[1];
  
  // Decode and write to file
  const buffer = Buffer.from(base64Data, 'base64');
  fs.writeFileSync(filename, buffer);
}

// Usage
saveVideo(result.video_url, 'output.mp4');

function downloadVideo(videoUrl, filename) {
  // Create blob from data URI
  const byteString = atob(videoUrl.split(',')[1]);
  const ab = new ArrayBuffer(byteString.length);
  const ia = new Uint8Array(ab);
  
  for (let i = 0; i < byteString.length; i++) {
    ia[i] = byteString.charCodeAt(i);
  }
  
  const blob = new Blob([ab], { type: 'video/mp4' });
  
  // Trigger download
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = filename;
  a.click();
  URL.revokeObjectURL(url);
}

// Usage
downloadVideo(result.video_url, 'generated_video.mp4');