google/veo3.1-fast/image-to-video

image-to-video

Veo3.1 Fast Image-to-Video API by Google

google/veo3.1-fast/image-to-video

Image-to-video

Bring still images to life with smooth, expressive motion. Veo 3.1 Image-to-Video transforms photos or keyframes into cinematic video sequences with realistic continuity and sound.

INPUT

Loading parameter configuration...

OUTPUT

Idle

Your generated videos will appear here

Configure your settings and click Run to get started

Your request will cost $0.08 per run. For $10 you can run this model approximately 125 times.

Here's what you can do next:

Seedance 2.0 Kling v3 Vidu Wan2.7

Parameters

Code Example
import requests
import time

# Step 1: Start video generation
generate_url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "google/veo3.1-fast/image-to-video",
    "prompt": "A beautiful sunset over the ocean with gentle waves",
    "width": 512,
    "height": 512,
    "duration": 3,
    "fps": 24,
}

generate_response = requests.post(generate_url, headers=headers, json=data)
generate_result = generate_response.json()
prediction_id = generate_result["data"]["id"]

# Step 2: Poll for result
poll_url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"

def check_status():
    while True:
        response = requests.get(poll_url, headers={"Authorization": "Bearer $ATLASCLOUD_API_KEY"})
        result = response.json()

        if result["data"]["status"] in ["completed", "succeeded"]:
            print("Generated video:", result["data"]["outputs"][0])
            return result["data"]["outputs"][0]
        elif result["data"]["status"] == "failed":
            raise Exception(result["data"]["error"] or "Generation failed")
        else:
            # Still processing, wait 2 seconds
            time.sleep(2)

video_url = check_status()

Install

Install the required package for your language.

pip install requests

Authentication

All API requests require authentication via an API key. You can get your API key from the Atlas Cloud dashboard.

export ATLASCLOUD_API_KEY="your-api-key-here"

HTTP Headers

import os

API_KEY = os.environ.get("ATLASCLOUD_API_KEY")
headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {API_KEY}"
}

Keep your API key secure

Never expose your API key in client-side code or public repositories. Use environment variables or a backend proxy instead.

Submit a request

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}
data = {
    "model": "your-model",
    "prompt": "A beautiful landscape"
}

response = requests.post(url, headers=headers, json=data)
print(response.json())

Submit a Request

Submit an asynchronous generation request. The API returns a prediction ID that you can use to check the status and retrieve the result.

POST/api/v1/model/generateVideo

Request Body

import requests

url = "https://api.atlascloud.ai/api/v1/model/generateVideo"
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer $ATLASCLOUD_API_KEY"
}

data = {
    "model": "google/veo3.1-fast/image-to-video",
    "input": {
        "prompt": "A beautiful sunset over the ocean with gentle waves"
    }
}

response = requests.post(url, headers=headers, json=data)
result = response.json()

print(f"Prediction ID: {result['id']}")
print(f"Status: {result['status']}")

Response

{
  "id": "pred_abc123",
  "status": "processing",
  "model": "model-name",
  "created_at": "2025-01-01T00:00:00Z"
}

Check Status

Poll the prediction endpoint to check the current status of your request.

GET/api/v1/model/prediction/{prediction_id}

Polling Example

import requests
import time

prediction_id = "pred_abc123"
url = f"https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

while True:
    response = requests.get(url, headers=headers)
    result = response.json()
    status = result["data"]["status"]
    print(f"Status: {status}")

    if status in ["completed", "succeeded"]:
        output_url = result["data"]["outputs"][0]
        print(f"Output URL: {output_url}")
        break
    elif status == "failed":
        print(f"Error: {result['data'].get('error', 'Unknown')}")
        break

    time.sleep(3)

Status Values

processingThe request is still being processed.

completedGeneration is complete. Outputs are available.

succeededGeneration succeeded. Outputs are available.

failedGeneration failed. Check the error field.

Completed Response

{
  "data": {
    "id": "pred_abc123",
    "status": "completed",
    "outputs": [
      "https://storage.atlascloud.ai/outputs/result.mp4"
    ],
    "metrics": {
      "predict_time": 45.2
    },
    "created_at": "2025-01-01T00:00:00Z",
    "completed_at": "2025-01-01T00:00:10Z"
  }
}

Upload Files

Upload files to Atlas Cloud storage and get a URL you can use in your API requests. Use multipart/form-data to upload.

POST/api/v1/model/uploadMedia

Upload Example

import requests

url = "https://api.atlascloud.ai/api/v1/model/uploadMedia"
headers = { "Authorization": "Bearer $ATLASCLOUD_API_KEY" }

with open("image.png", "rb") as f:
    files = {"file": ("image.png", f, "image/png")}
    response = requests.post(url, headers=headers, files=files)

result = response.json()
download_url = result["data"]["download_url"]
print(f"File URL: {download_url}")

Response

{
  "data": {
    "download_url": "https://storage.atlascloud.ai/uploads/abc123/image.png",
    "file_name": "image.png",
    "content_type": "image/png",
    "size": 1024000
  }
}

Input Schema

The following parameters are accepted in the request body.

Total: 0Required: 0Optional: 0

No parameters available.

Example Request Body

{
  "model": "google/veo3.1-fast/image-to-video"
}

Output Schema

The API returns a prediction response with the generated output URLs.

idstringrequired

Unique identifier for the prediction.

statusstringrequired

Current status of the prediction.

processingcompletedsucceededfailed

modelstringrequired

The model used for generation.

outputsarray[string]

Array of output URLs. Available when status is "completed".

errorstring

Error message if status is "failed".

metricsobject

Performance metrics.

predict_timenumber

Time taken for video generation in seconds.

created_atstringrequired

ISO 8601 timestamp when the prediction was created.

Format: date-time

completed_atstring

ISO 8601 timestamp when the prediction was completed.

Format: date-time

Example Response

{
  "id": "pred_abc123",
  "status": "completed",
  "model": "model-name",
  "outputs": [
    "https://storage.atlascloud.ai/outputs/result.mp4"
  ],
  "metrics": {
    "predict_time": 45.2
  },
  "created_at": "2025-01-01T00:00:00Z",
  "completed_at": "2025-01-01T00:00:10Z"
}

Atlas Cloud Skills

Atlas Cloud Skills integrates 300+ AI models directly into your AI coding assistant. One command to install, then use natural language to generate images, videos, and chat with LLMs.

Supported Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ supported clients

Install

npx skills add AtlasCloudAI/atlas-cloud-skills

Setup API Key

Get your API key from the Atlas Cloud dashboard and set it as an environment variable.

export ATLASCLOUD_API_KEY="your-api-key-here"

Capabilities

Once installed, you can use natural language in your AI assistant to access all Atlas Cloud models.

Image GenerationGenerate images with models like Nano Banana 2, Z-Image, and more.

Video CreationCreate videos from text or images with Kling, Vidu, Veo, etc.

LLM ChatChat with Qwen, DeepSeek, and other large language models.

Media UploadUpload local files for image editing and image-to-video workflows.

Learn more

github.com/AtlasCloudAI/atlas-cloud-skills

MCP Server

Atlas Cloud MCP Server connects your IDE with 300+ AI models via the Model Context Protocol. Works with any MCP-compatible client.

Supported Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ supported clients

Install

npx -y atlascloud-mcp

Configuration

Add the following configuration to your IDE's MCP settings file.

{
  "mcpServers": {
    "atlascloud": {
      "command": "npx",
      "args": [
        "-y",
        "atlascloud-mcp"
      ],
      "env": {
        "ATLASCLOUD_API_KEY": "your-api-key-here"
      }
    }
  }
}

Available Tools

atlas_generate_imageGenerate images from text prompts.

atlas_generate_videoCreate videos from text or images.

atlas_chatChat with large language models.

atlas_list_modelsBrowse 300+ available AI models.

atlas_quick_generateOne-step content creation with auto model selection.

atlas_upload_mediaUpload local files for API workflows.

Learn more

github.com/AtlasCloudAI/mcp-server

API Schema

Schema not available

No examples available

Please log in to view request history

You need to be logged in to access your model request history.

Google Veo 3 — Image-to-Video (I2V) Fast

Veo 3 I2V Fast is the high-speed, cost-optimized variant of Google DeepMind's Veo 3 image-to-video model.

It transforms static images into cinematic 1080p videos with smooth, realistic motion and natural lighting — all while delivering results up to 30% faster than the standard version.

Perfect for creators who need rapid, high-quality motion generation for social content, concept visualization, and creative storytelling.

Why it stands out

From Image to Motion

Transform a single image into a natural, dynamic video sequence while preserving its original composition and style.
Cinematic Realism

Produces high-fidelity motion with natural lighting, accurate perspective, and fluid camera transitions.
Native Audio Generation

Automatically generates synchronized sound—including ambient noise, effects, and light music—perfectly aligned with the visuals.
Dialogue & Lip-Sync

Enables speaking characters or realistic expressions, ideal for storytelling, marketing, and short-form content.
Consistent Subject & Style

Retains the identity, color tone, and visual integrity of your input image throughout the motion sequence.

Pricing

Every run needs $0.15/second (both 720p and 1080p)

Without audio needs $0.10/second

✅ Commercial use allowed

How to Use

Upload an Image

Choose a clear, high-quality still image—this defines the subject, framing, and overall style.
Write a Prompt

Describe the desired motion, mood, and camera movement.

Example: “Slow cinematic zoom out as wind moves through the trees and sunlight flickers across the leaves.”
Adjust Settings

Select the video duration (up to 8 seconds) and output resolution (up to 1080p).
Generate the Video

Submit your prompt and image—Veo 3 I2V automatically creates motion, lighting, and audio.
Preview & Download

Review the result, refine the prompt if needed, and download the final MP4.

Pro Tips

Use bright, high-contrast images for clearer motion and lighting.
Keep prompts focused on a single subject or action for best stability.
Add camera directions like “tracking shot,” “slow pan,” or “handheld style” to control movement.
Specify lighting and mood (e.g., bright daylight, soft sunset glow).
Avoid conflicting motion requests to maintain smooth results.

Notes

Actual processing time depends on queue load and resolution.
Optimized for cinematic shorts, ads, and social media clips.
Ensure your uploaded image is clear, accessible, and legally usable.
Please ensure your prompts comply with Google's Safety Guidelines — if an error occurs, revise your prompt and try again.

Explore Similar Models

NEW

image-to-video

DEV

Gemini Omni Flash Image-to-Video Developer

Gemini Omni Flash is Google's multimodal video generation model. This image-to-video variant creates subject-consistent videos from up to 7 reference images combined with a text prompt, preserving visual identity across the full generated video.

Gemini Omni Flash Text-to-Video Developer

Gemini Omni Flash is Google's multimodal video generation model. This text-to-video variant generates high-quality cinematic videos from text prompts with support for multiple resolutions, aspect ratios, and controllable duration.

Veo 3.1 Lite Text-to-video

High-efficiency Veo 3.1 Lite text-to-video: create video with synchronized audio from text prompts. Targets high-volume applications with strong price efficiency; 720p/1080p and flexible duration options. Does not support 4K outputs or Extension.

Veo 3.1 Lite Start-End Frame to Video

Veo 3.1 Lite start-end frame to video: generate motion between a first and last frame with audio. Lightweight, developer-oriented option with 8s duration and 720p/1080p. Does not support 4K outputs or Extension.

Veo 3.1 Lite Image-to-video

High-efficiency Veo 3.1 Lite image-to-video: animate an input image into video with synchronized audio. Cost-effective for scalable workflows; supports 720p/1080p and common aspect ratios. Does not support 4K outputs or Extension.

Veo3.1 Fast Text-to-video

Generate visually compelling videos from text in record time. Veo 3.1 Fast Text-to-Video prioritizes speed and responsiveness while maintaining impressive fidelity for rapid creative iteration.

Veo3.1 Image-to-video

Quickly animate static images into motion-rich, high-quality clips. Veo 3.1 Fast Image-to-Video accelerates rendering for fast previews and iterative visual storytelling.

Veo3.1 Reference-to-video

Create richly detailed videos guided by visual references. Veo 3.1 Reference-to-Video preserves characters, style, and composition across scenes for consistent, visually coherent storytelling.

Veo3.1 Text-to-video

Generate high-fidelity videos from text prompts with Google’s most advanced generative video model. Veo 3.1 delivers cinematic quality, dynamic camera motion, and lifelike detail for storytelling and creative production.

Gemini Omni Flash Reference-to-Video Developer

Gemini Omni Flash is Google's multimodal video generation model. This reference-to-video variant transforms existing video clips using reference images and text prompts, enabling video style transfer, scene editing, and character insertion.

From

$0.16/SEC