Gemini Omni API Tutorial — Developer Guide for AI Video Integration

Prerequisites

Step 1: Setup and Authentication

Install the SDK and configure your API key:

pip install google-generativeai

# Set your API key as an environment variable
export GOOGLE_API_KEY="your-api-key-here"

Then initialize the client in your code:

import google.generativeai as genai
import os

genai.configure(api_key=os.environ["GOOGLE_API_KEY"])

For production server-side applications, use a service account instead:

# Using Application Default Credentials (recommended for production)
from google.cloud import aiplatform

aiplatform.init(
    project="your-project-id",
    location="us-central1"
)

Step 2: Text-to-Video Generation

Generate a video from a text prompt using the Python SDK:

import google.generativeai as genai

# Expected model name — check Google's docs for the actual name
model = genai.GenerativeModel("gemini-omni-video")

response = model.generate_content(
    prompt="A golden retriever running through a meadow in slow motion, cinematic lighting",
    generation_config={
        "duration_seconds": 8,
        "resolution": "1080p",
        "fps": 24,
    }
)

# response contains a video URI
video_uri = response.candidates[0].content.parts[0].video.uri
print(f"Video generated: {video_uri}")

The same request via REST API:

curl -X POST \
  # Expected endpoint — check Google's docs for the actual URL
  "https://generativelanguage.googleapis.com/v1beta/models/gemini-omni-video:generateContent" \
  -H "Content-Type: application/json" \
  -H "x-goog-api-key: YOUR_API_KEY" \
  -d '{
    "contents": [{
      "parts": [{
        "text": "A golden retriever running through a meadow, cinematic lighting"
      }]
    }],
    "generationConfig": {
      "durationSeconds": 8,
      "resolution": "1080p",
      "fps": 24
    }
  }'

Step 3: Image-to-Video Generation

Upload a reference image and animate it with a text prompt:

import google.generativeai as genai

# Expected model name — check Google's docs for the actual name
model = genai.GenerativeModel("gemini-omni-video")

# Upload your reference image
sample_file = genai.upload_file(path="product.jpg")

response = model.generate_content(
    [
        {"inline_data": sample_file},
        {"text": "Slow 360-degree rotation, soft studio lighting, white background"},
    ],
    generation_config={
        "duration_seconds": 5,
        "resolution": "1080p",
    }
)

video_uri = response.candidates[0].content.parts[0].video.uri
print(f"Video generated: {video_uri}")

Step 4: Polling for Long-Running Operations

For longer videos, the API is expected to return an operation ID. Poll until complete:

import time

def generate_video_long(prompt: str, max_wait: int = 300):
    """Submit a video generation request and poll for completion."""
    operation = model.generate_content(
        prompt=prompt,
        generation_config={"duration_seconds": 15, "resolution": "1080p"},
    )
    
    elapsed = 0
    while not operation.done and elapsed < max_wait:
        time.sleep(10)
        elapsed += 10
        print(f"Waiting... {elapsed}s elapsed")
    
    if operation.done:
        video_uri = operation.result.candidates[0].content.parts[0].video.uri
        return video_uri
    else:
        raise TimeoutError("Video generation timed out")

video = generate_video_long(
    "Aerial drone shot of a mountain lake at sunset, cinematic 4K"
)

Step 5: Error Handling

Handle common API errors gracefully in production:

from google.api_core import exceptions

def safe_generate_video(prompt: str, retries: int = 3):
    """Generate video with retry logic and error handling."""
    for attempt in range(retries):
        try:
            response = model.generate_content(
                prompt=prompt,
                generation_config={"duration_seconds": 8, "resolution": "720p"},
            )
            return response.candidates[0].content.parts[0].video.uri
        
        except exceptions.ResourceExhausted:
            print("Rate limited. Waiting 60s before retry...")
            time.sleep(60)
        
        except exceptions.InvalidArgument as e:
            print(f"Invalid request: {e}")
            return None  # Don't retry client errors
        
        except exceptions.GoogleAPIError as e:
            print(f"API error (attempt {attempt + 1}): {e}")
            time.sleep(10)
    
    raise Exception(f"Failed after {retries} retries")

Common error codes to handle:

Rate Limits and Pricing

Pricing for Gemini Omni is expected to follow Google's generative AI model pricing structure:

These are estimates based on Google's current AI pricing patterns. Exact pricing will be published when Gemini Omni launches. For currently available video generation at transparent pricing, check out our platform.

Best Practices for Production

Vertex AI Direct vs Third-Party Platforms

Explore More

Frequently Asked Questions