Examples

Practical code examples and use cases for the VEO3 API. Learn how to generate videos with step-by-step tutorials and complete code samples.

Text-to-Video
Generate videos from text prompts
Basic
Image-to-Video
Transform static images into videos
Intermediate
Batch Processing
Process multiple videos efficiently
Advanced
Quick Start Example
Complete workflow from prompt to video download

Complete JavaScript Example

async function generateVideo() {
  const API_KEY = 'your-api-key-here';
  const BASE_URL = 'https://api.veo3gen.co/v1';
  
  try {
    // Step 1: Generate video
    const generateResponse = await fetch(`${BASE_URL}/generate`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        prompt: "A serene sunset over mountains with birds flying",
        model: "veo-3.0-generate",
        duration: 5,
        aspect_ratio: "16:9",
        fps: 24
      })
    });
    
    const generateData = await generateResponse.json();
    
    if (!generateResponse.ok) {
      throw new Error(`Generate failed: ${generateData.error.message}`);
    }
    
    console.log('Video generation started:', generateData.id);
    
    // Step 2: Poll for completion
    const videoId = generateData.id;
    let status = 'processing';
    
    while (status === 'processing') {
      await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
      
      const statusResponse = await fetch(`${BASE_URL}/status/${videoId}`, {
        headers: {
          'Authorization': `Bearer ${API_KEY}`
        }
      });
      
      const statusData = await statusResponse.json();
      status = statusData.status;
      
      console.log('Status:', status);
      
      if (status === 'completed') {
        console.log('Video completed!');
        console.log('Download URL:', statusData.download_url);
        break;
      } else if (status === 'failed') {
        throw new Error(`Video generation failed: ${statusData.error}`);
      }
    }
    
    // Step 3: Download video
    const downloadResponse = await fetch(`${BASE_URL}/download/${videoId}`, {
      headers: {
        'Authorization': `Bearer ${API_KEY}`
      }
    });
    
    if (downloadResponse.ok) {
      const blob = await downloadResponse.blob();
      const url = URL.createObjectURL(blob);
      
      // Create download link
      const a = document.createElement('a');
      a.href = url;
      a.download = `video-${videoId}.mp4`;
      document.body.appendChild(a);
      a.click();
      document.body.removeChild(a);
      
      URL.revokeObjectURL(url);
      console.log('Video downloaded successfully!');
    }
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

// Usage
generateVideo();
Image-to-Video Example
Transform static images into dynamic videos
async function generateFromImage() {
  const API_KEY = 'your-api-key-here';
  const BASE_URL = 'https://api.veo3gen.co/v1';
  
  // Convert image to base64
  const imageInput = document.getElementById('imageInput');
  const file = imageInput.files[0];
  
  if (!file) {
    alert('Please select an image');
    return;
  }
  
  const base64Image = await fileToBase64(file);
  
  try {
    const response = await fetch(`${BASE_URL}/image-to-video`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        image: base64Image,
        prompt: "Add gentle movement to this scene with flowing water",
        model: "veo-3.0-generate",
        duration: 3,
        motion_strength: 0.7
      })
    });
    
    const data = await response.json();
    
    if (!response.ok) {
      throw new Error(`Generation failed: ${data.error.message}`);
    }
    
    console.log('Image-to-video generation started:', data.id);
    
    // Poll for completion (same as text-to-video)
    await pollForCompletion(data.id);
    
  } catch (error) {
    console.error('Error:', error.message);
  }
}

function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => resolve(reader.result);
    reader.onerror = error => reject(error);
  });
}

async function pollForCompletion(videoId) {
  const API_KEY = 'your-api-key-here';
  const BASE_URL = 'https://api.veo3gen.co/v1';
  
  while (true) {
    const response = await fetch(`${BASE_URL}/status/${videoId}`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    });
    
    const data = await response.json();
    
    if (data.status === 'completed') {
      console.log('Video ready!', data.download_url);
      break;
    } else if (data.status === 'failed') {
      throw new Error(`Generation failed: ${data.error}`);
    }
    
    await new Promise(resolve => setTimeout(resolve, 5000));
  }
}
Batch Processing Example
Process multiple videos efficiently with queue management

JavaScript Batch Processing

class VEO3BatchProcessor {
  constructor(apiKey, maxConcurrent = 5) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.veo3gen.co/v1';
    this.maxConcurrent = maxConcurrent;
    this.queue = [];
    this.processing = [];
    this.completed = [];
    this.failed = [];
  }
  
  async processBatch(prompts) {
    console.log(`Starting batch processing of ${prompts.length} videos`);
    
    // Add all prompts to queue
    this.queue = prompts.map((prompt, index) => ({
      id: index,
      prompt,
      status: 'queued'
    }));
    
    // Process queue
    const workers = [];
    for (let i = 0; i < this.maxConcurrent; i++) {
      workers.push(this.worker());
    }
    
    await Promise.all(workers);
    
    return {
      completed: this.completed,
      failed: this.failed,
      total: prompts.length
    };
  }
  
  async worker() {
    while (this.queue.length > 0) {
      const job = this.queue.shift();
      if (!job) break;
      
      try {
        job.status = 'processing';
        this.processing.push(job);
        
        console.log(`Processing job ${job.id}: ${job.prompt}`);
        
        // Generate video
        const response = await fetch(`${this.baseUrl}/generate`, {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${this.apiKey}`,
            'Content-Type': 'application/json'
          },
          body: JSON.stringify({
            prompt: job.prompt,
            model: 'veo-3.0-fast' // Use fast model for batch processing
          })
        });
        
        const data = await response.json();
        
        if (!response.ok) {
          throw new Error(data.error.message);
        }
        
        job.videoId = data.id;
        job.status = 'waiting';
        
        // Wait for completion
        await this.waitForCompletion(job);
        
        // Remove from processing
        this.processing = this.processing.filter(p => p.id !== job.id);
        this.completed.push(job);
        
        console.log(`Job ${job.id} completed`);
        
      } catch (error) {
        job.error = error.message;
        job.status = 'failed';
        this.processing = this.processing.filter(p => p.id !== job.id);
        this.failed.push(job);
        
        console.error(`Job ${job.id} failed: ${error.message}`);
      }
    }
  }
  
  async waitForCompletion(job) {
    while (true) {
      const response = await fetch(`${this.baseUrl}/status/${job.videoId}`, {
        headers: { 'Authorization': `Bearer ${this.apiKey}` }
      });
      
      const data = await response.json();
      
      if (data.status === 'completed') {
        job.downloadUrl = data.download_url;
        break;
      } else if (data.status === 'failed') {
        throw new Error(data.error || 'Generation failed');
      }
      
      await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds
    }
  }
  
  getProgress() {
    return {
      queued: this.queue.length,
      processing: this.processing.length,
      completed: this.completed.length,
      failed: this.failed.length
    };
  }
}

// Usage
const processor = new VEO3BatchProcessor('your-api-key-here', 3);

const prompts = [
  "A sunset over the ocean",
  "A forest with morning mist",
  "City skyline at night",
  "Mountain landscape with snow",
  "Desert with sand dunes"
];

processor.processBatch(prompts).then(result => {
  console.log('Batch processing completed:', result);
}).catch(error => {
  console.error('Batch processing failed:', error);
});
React Hook Example
Custom React hook for video generation with state management

useVEO3Generator Hook

import { useState, useCallback } from 'react';

export function useVEO3Generator(apiKey) {
  const [isGenerating, setIsGenerating] = useState(false);
  const [progress, setProgress] = useState(null);
  const [error, setError] = useState(null);
  const [result, setResult] = useState(null);
  
  const generateVideo = useCallback(async (options) => {
    setIsGenerating(true);
    setError(null);
    setResult(null);
    setProgress('Starting generation...');
    
    try {
      const response = await fetch('https://api.veo3gen.co/v1/generate', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify(options)
      });
      
      const data = await response.json();
      
      if (!response.ok) {
        throw new Error(data.error.message);
      }
      
      setProgress('Video generation in progress...');
      
      // Poll for completion
      const videoId = data.id;
      while (true) {
        await new Promise(resolve => setTimeout(resolve, 5000));
        
        const statusResponse = await fetch(`https://api.veo3gen.co/v1/status/${videoId}`, {
          headers: { 'Authorization': `Bearer ${apiKey}` }
        });
        
        const statusData = await statusResponse.json();
        
        if (statusData.status === 'completed') {
          setProgress('Video completed!');
          setResult({
            id: videoId,
            downloadUrl: statusData.download_url,
            thumbnail: statusData.thumbnail_url
          });
          break;
        } else if (statusData.status === 'failed') {
          throw new Error(statusData.error || 'Generation failed');
        }
        
        setProgress(`Processing... (${statusData.progress || 0}%)`);
      }
      
    } catch (err) {
      setError(err.message);
    } finally {
      setIsGenerating(false);
    }
  }, [apiKey]);
  
  const reset = useCallback(() => {
    setIsGenerating(false);
    setProgress(null);
    setError(null);
    setResult(null);
  }, []);
  
  return {
    generateVideo,
    isGenerating,
    progress,
    error,
    result,
    reset
  };
}

// Usage in component
function VideoGenerator() {
  const { generateVideo, isGenerating, progress, error, result, reset } = 
    useVEO3Generator('your-api-key-here');
  
  const handleGenerate = () => {
    generateVideo({
      prompt: "A beautiful sunset over mountains",
      model: "veo-3.0-generate",
      duration: 5
    });
  };
  
  return (
    <div className="p-4">
      <button 
        onClick={handleGenerate} 
        disabled={isGenerating}
        className="px-4 py-2 bg-blue-500 text-white rounded disabled:opacity-50"
      >
        {isGenerating ? 'Generating...' : 'Generate Video'}
      </button>
      
      {progress && (
        <div className="mt-4 p-2 bg-blue-100 rounded">
          {progress}
        </div>
      )}
      
      {error && (
        <div className="mt-4 p-2 bg-red-100 text-red-700 rounded">
          Error: {error}
        </div>
      )}
      
      {result && (
        <div className="mt-4 p-2 bg-green-100 rounded">
          <p>Video generated successfully!</p>
          <a 
            href={result.downloadUrl} 
            download
            className="text-blue-500 underline"
          >
            Download Video
          </a>
        </div>
      )}
      
      {(error || result) && (
        <button 
          onClick={reset}
          className="mt-2 px-4 py-2 bg-gray-500 text-white rounded"
        >
          Reset
        </button>
      )}
    </div>
  );
}
Error Handling & Retry Logic
Robust error handling with exponential backoff

Production-Ready Error Handling

class VEO3ClientWithRetry {
  constructor(apiKey, options = {}) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.veo3gen.co/v1';
    this.maxRetries = options.maxRetries || 3;
    this.baseDelay = options.baseDelay || 1000;
    this.maxDelay = options.maxDelay || 30000;
  }
  
  async makeRequest(endpoint, options = {}) {
    const url = `${this.baseUrl}/${endpoint}`;
    const config = {
      ...options,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers
      }
    };
    
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        const response = await fetch(url, config);
        
        // Handle rate limiting
        if (response.status === 429) {
          const retryAfter = response.headers.get('X-RateLimit-Retry-After');
          const delay = retryAfter ? parseInt(retryAfter) * 1000 : this.calculateDelay(attempt);
          
          if (attempt < this.maxRetries) {
            console.log(`Rate limited. Retrying in ${delay}ms...`);
            await this.sleep(delay);
            continue;
          }
        }
        
        // Handle server errors (5xx)
        if (response.status >= 500) {
          if (attempt < this.maxRetries) {
            const delay = this.calculateDelay(attempt);
            console.log(`Server error. Retrying in ${delay}ms...`);
            await this.sleep(delay);
            continue;
          }
        }
        
        // Handle client errors (4xx)
        if (response.status >= 400) {
          const errorData = await response.json();
          throw new APIError(errorData.error.message, response.status, errorData.error.code);
        }
        
        return response;
        
      } catch (error) {
        if (error instanceof APIError) {
          throw error; // Don't retry client errors
        }
        
        if (attempt === this.maxRetries) {
          throw new NetworkError(`Request failed after ${this.maxRetries + 1} attempts: ${error.message}`);
        }
        
        const delay = this.calculateDelay(attempt);
        console.log(`Network error. Retrying in ${delay}ms...`);
        await this.sleep(delay);
      }
    }
  }
  
  calculateDelay(attempt) {
    // Exponential backoff with jitter
    const delay = Math.min(
      this.baseDelay * Math.pow(2, attempt),
      this.maxDelay
    );
    
    // Add jitter to prevent thundering herd
    const jitter = Math.random() * 0.1 * delay;
    return Math.floor(delay + jitter);
  }
  
  sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
  
  async generateVideo(options) {
    try {
      const response = await this.makeRequest('generate', {
        method: 'POST',
        body: JSON.stringify(options)
      });
      
      return await response.json();
      
    } catch (error) {
      if (error instanceof APIError) {
        // Handle specific API errors
        switch (error.code) {
          case 'INSUFFICIENT_CREDITS':
            throw new Error('Not enough credits to generate video. Please add credits to your account.');
          case 'INVALID_PROMPT':
            throw new Error('The prompt contains invalid content. Please modify your prompt.');
          case 'UNSUPPORTED_MODEL':
            throw new Error('The specified model is not supported.');
          default:
            throw new Error(`API Error: ${error.message}`);
        }
      }
      
      throw error;
    }
  }
}

// Custom Error Classes
class APIError extends Error {
  constructor(message, status, code) {
    super(message);
    this.name = 'APIError';
    this.status = status;
    this.code = code;
  }
}

class NetworkError extends Error {
  constructor(message) {
    super(message);
    this.name = 'NetworkError';
  }
}

// Usage
const client = new VEO3ClientWithRetry('your-api-key-here', {
  maxRetries: 5,
  baseDelay: 1000,
  maxDelay: 60000
});

try {
  const result = await client.generateVideo({
    prompt: "A beautiful sunset",
    model: "veo-3.0-generate"
  });
  console.log('Video generated:', result.id);
} catch (error) {
  console.error('Failed to generate video:', error.message);
}
Best Practices
  • • Always implement proper error handling
  • • Use exponential backoff for retries
  • • Monitor rate limits and adjust accordingly
  • • Cache results when possible
  • • Use webhooks for long-running operations
  • • Implement proper logging and monitoring
Common Pitfalls
  • • Not handling rate limits properly
  • • Polling too frequently for status updates
  • • Not implementing proper timeout handling
  • • Exposing API keys in client-side code
  • • Not validating inputs before API calls
  • • Ignoring error codes and messages