google/veo3.1/image-to-video

image-to-video

Veo3.1 Image-to-Video API by Google

google/veo3.1/image-to-video

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.

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.2 per run. For $10 you can run this model approximately 50 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/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.

bash

pip install requests

Authentication

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

bash

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

HTTP Headers

python

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/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

json

{
  "model": "google/veo3.1/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

json

{
  "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

bash

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.

bash

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

bash

npx -y atlascloud-mcp

Configuration

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

json

{
  "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.1 — Image-to-Video (I2V) Model

Veo 3.1 I2V is Google DeepMind’s latest image-to-video generation model — an evolution of Veo’s cinematic foundation. It transforms a single still image or a pair of start & end frames into a high-fidelity 1080p motion sequence with natural movement, realistic lighting, and synchronized contextual audio.

Perfect for storyboarding, concept animation, and creative scene development, Veo 3.1 I2V captures the feeling of camera motion and environmental change while preserving your image’s style and composition.

Why it stands out

** Cinematic Motion Generation**

Animates still images with realistic subject and camera movement — from subtle pans to sweeping transitions.
** Frame Interpolation**

Supports single-frame animation and two-frame transitions — letting you morph from one image to another with fluid continuity.
** Native Audio Support**

Adds synchronized ambient sound, dialogue, or music automatically aligned with visual motion.
** Contextual Understanding**

Interprets both image content and prompt text to guide scene flow and atmosphere.
** High-Resolution Output**

Generates at 720p or 1080p, 24 FPS, and supports landscape (16:9) or portrait (9:16) aspect ratios.

Key Parameters

prompt — Describe motion or story context (e.g., “Slow dolly zoom on a city skyline as sunset light fades”).
image — Provide a starting frame (JPEG / PNG / WEBP).
lastFrame (optional) — Provide an ending frame to create an interpolation-style transition.
durationSeconds — Choose video length: 4s, 6s, or 8s.
resolution — 720p or 1080p.
aspectRatio — Landscape (16:9) or Portrait (9:16).

Pricing (Preview Stage)

Model	Description	Input Type	Output	Price
Veo 3.1 (Video + Audio)	Generate videos with synchronized sound	Image / Image Pair	Video + Audio	$0.40 / sec
Veo 3.1 (Video only)	Generate silent motion sequences	Image / Image Pair	Video	$0.20 / sec

Typical cost: ~$3.20 for an 8-second 1080p video (standard mode).

How to Use

Upload your starting image

Use a clear, well-lit frame.
(Optional) Add a last frame

Provide an ending image if you want a smooth transition.
Write your prompt

Describe the motion or transformation (e.g., “camera slowly zooms out as night falls”).
Set parameters

Choose duration (4s / 6s / 8s), resolution (720p / 1080p), and aspect ratio (16:9 or 9:16).
Generate video

Submit your request — Veo 3.1 I2V will produce motion, lighting, and audio automatically.

Pro Tips

Use consistent framing between start and end images for smoother interpolation.
Add camera verbs like “pan,” “tilt,” “dolly,” for cinematic control.
Keep prompts concise and clear — focus on movement and lighting.
For realistic transitions, limit drastic composition or color shifts between frames.
To ensure repeatability, use the same random seed value.

Notes & Limitations

Supported durations: 4, 6, or 8 seconds.
Frame rate: 24 FPS (fixed).
Generation time: ~2–3 minutes for 8s @1080p.

Explore Similar Models

NEW

text-to-video

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 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.

From

$0.08/SEC

Start From 300+ Models,

Explore all models

Veo3.1 Image-to-Video API by Google

INPUT

OUTPUT

Parameters

Code Example

Install

Authentication

HTTP Headers

Submit a request

Submit a Request

Request Body

Response

Check Status

Polling Example

Status Values

Completed Response

Upload Files

Upload Example

Response

Input Schema

Example Request Body

Output Schema

Example Response

Atlas Cloud Skills

Supported Clients

Install

Setup API Key

Capabilities

MCP Server

Supported Clients

Install

Configuration

Available Tools

API Schema

Please log in to view request history

Google Veo 3.1 — Image-to-Video (I2V) Model

Why it stands out

Key Parameters

Pricing (Preview Stage)

How to Use

Pro Tips

Notes & Limitations

Explore Similar Models

Veo 3.1 Lite Text-to-video

Veo 3.1 Lite Start-End Frame to Video

Veo 3.1 Lite Image-to-video

Veo3.1 Fast Image-to-video

Start From 300+ Models,

Join our Discord community