PixVerse v3.5: Image to Video Image to Video

Readme

PixVerse: Image-to-Video Generation API

Transform static images into dynamic videos with PixVerse, a powerful API for creating high-quality video content from single images and text prompts.

Overview

PixVerse enables developers and creators to generate engaging video content programmatically from still images. Whether you're building a content creation app, enhancing user experiences, or automating video production, PixVerse provides a reliable and efficient solution with support for multiple resolutions and styles.

Getting Started

Getting up and running with PixVerse takes just a few minutes. Here's how to begin:

First, install the client library for your preferred language:

For JavaScript/TypeScript:

bash
npm install --save @fal-ai/client

For Python:

bash
pip install fal-client

Configure your authentication:

javascript
import { fal } from "@fal-ai/client";

fal.config({
  credentials: "YOUR_FAL_KEY_HERE"
});

Basic Usage

Here's a simple example of generating a video from an image:

javascript
import { fal } from "@fal-ai/client";

const result = await fal.subscribe("fal-ai/pixverse/v3.5/image-to-video", {
  input: {
    image_url: "https://example.com/your-image.jpg",
    prompt: "A serene mountain landscape with clouds rolling over peaks"
  }
});

Key Features

Transform Static Content Convert any still image into fluid, natural-looking video content while maintaining visual quality and coherence.

Multiple Resolution Options Choose from 360p, 540p, 720p, or 1080p output resolutions to match your needs and budget.

Advanced Motion Control Fine-tune movement with motion modes (normal or fast) and style presets to achieve your desired effect.

Fast Processing Generation typically completes in approximately 1 minute, making it suitable for production workflows.

API Parameters

Input Parameters:

• `image_url` (required): URL of the input image
• `prompt` (required): Text description to guide the video generation
• `duration`: Video length - 5 or 8 seconds
• `quality`: Resolution - "360p", "540p", "720p", or "1080p"
• `motion_mode`: "normal" or "fast" (fast only available for 5s videos)
• `style`: Style preset for generation (default: "auto")
• `negative_prompt`: Elements to avoid in the generation
• `seed`: Random seed for reproducible results
• `model`: Model version (default: "v3.5")
• `water_mark`: Add watermark to output (default: false)

Implementation Best Practices

Quality Optimization

Start with high-resolution source images for best results. The API performs best with images in standard aspect ratios.

Error Handling

Always implement proper error handling to manage API responses:

javascript
try {
  const result = await fal.subscribe("fal-ai/pixverse/v3.5/image-to-video", {
    input: {
      image_url: sourceUrl,
      prompt: "Your description"
    }
  });
  // Process successful result
} catch (error) {
  console.error("Video generation failed:", error.message);
  // Handle error appropriately
}

Queue-Based Processing

For asynchronous workflows:

javascript
// Submit request
const { request_id } = await fal.queue.submit("fal-ai/pixverse/v3.5/image-to-video", {
  input: {
    image_url: "your-image-url",
    prompt: "Your prompt"
  },
  webhookUrl: "https://optional.webhook.url/for/results"
});

// Check status
const status = await fal.queue.status("fal-ai/pixverse/v3.5/image-to-video", {
  requestId: request_id,
  logs: true
});

// Get result
const result = await fal.queue.result("fal-ai/pixverse/v3.5/image-to-video", {
  requestId: request_id
});

Advanced Configuration

PixVerse supports several parameters to customize video generation:

javascript
const advancedOptions = {
  input: {
    image_url: "https://example.com/image.jpg",
    prompt: "Dynamic camera movement over landscape",
    duration: 5,          // 5 or 8 seconds
    quality: "720p",      // Resolution selection
    motion_mode: "fast",  // Available for 5s videos
    style: "cinematic",   // Style preset
    seed: 12345          // For reproducible results
  }
};

Technical Specifications

Processing Capabilities:

• Input formats: JPG, JPEG, PNG, WebP, GIF, AVIF
• Output format: MP4
• Processing time: Approximately 1 minute
• Model version: v3.5

Supported Resolutions:

• 360p and 540p: $0.15 per 5-second video
• 720p: $0.20 per 5-second video
• 1080p: $0.40 per 5-second video

File Upload Support

Upload local images using the file storage API:

javascript
import { fal } from "@fal-ai/client";

const file = new File([imageData], "image.jpg", { type: "image/jpeg" });
const url = await fal.storage.upload(file);

const result = await fal.subscribe("fal-ai/pixverse/v3.5/image-to-video", {
  input: {
    image_url: url,
    prompt: "Your video description"
  }
});

Integration Support

Our documentation includes complete reference implementations for:

• React/Next.js applications
• Python backend services
• Node.js environments
• REST API clients

Visit our API reference for detailed endpoint specifications and response formats.

Pricing and Usage

Transparent, usage-based pricing that scales with your needs:

5-second videos:

• 360p and 540p: $0.15 per video
• 720p: $0.20 per video
• 1080p: $0.40 per video

8-second videos pricing scales proportionally.

No subscription necessary - pay only for what you use.

View detailed pricing or contact sales for enterprise solutions.

Getting Help

For technical support or implementation guidance:

• Review our API documentation
• Visit fal.ai documentation
• Join our developer community
• Contact our support team at support@fal.ai

Start building with PixVerse today to bring your static images to life with fluid, natural motion.