google/veo3.1/text-to-video

text-to-video

Veo3.1 Text-to-Video API by Google

google/veo3.1/text-to-video

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.

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/text-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/text-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/text-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 — Text-to-Video (T2V) Model

Veo 3.1 T2V is the latest text-to-video model from Google DeepMind, designed to bring cinematic storytelling to life through text. It generates high-fidelity 1080p videos with synchronized, context-aware audio, realistic motion, and narrative consistency — making it one of the most advanced generative video systems ever released.

Why it stands out

Cinematic Realism

Produces natural lighting, smooth camera transitions, and accurate perspective for film-like motion.
Native Audio Generation

Generates synchronized ambient sound, dialogue, and music directly aligned with the visuals.
Dialogue & Lip-Sync

Supports speaking characters and realistic facial expressions — perfect for storytelling, marketing, or short-form content.
Subject Consistency (R2V)

Maintains a character’s or object’s identity across frames using 1–3 reference images.
Video Interpolation

Seamlessly animates transitions between two given frames — ideal for smooth start-to-end storytelling.
Flexible Output

Supports both 720p and 1080p, at 24 FPS, duration for 4s, 6s, 8s, and in both 16:9 (landscape) and 9:16 (portrait) formats.

Key Parameters

prompt — Describe your scene or story (e.g., “A drone shot flying over Las Vegas, transitioning from day to night with soft jazz in the background”).
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	Text / Image	Video + Audio	$0.40 / sec
Veo 3.1 (Video only)	Generate high-quality silent videos	Text / Image	Video	$0.20 / sec

Minimum cost: ~$3.20 per clip (based on 8s @ 1080p).

How to Use

Write a Prompt

Describe the desired motion, camera style, lighting, and sound.

Example: “A cinematic sunset over the ocean, waves glimmering as seagulls fly across the horizon.”
Adjust Parameters

Select duration, resolution (720p/1080p), and aspect ratio.
Generate

Submit your request — Veo 3.1 will render motion, lighting, and synchronized audio.
Preview & Download

Review your video, refine your prompt if needed, then download the final MP4.

Pro Tips

Keep prompts focused on one main action or subject for better coherence.
Use camera verbs like “tracking,” “zoom out,” or “handheld” for cinematic control.
Mention lighting and mood cues (e.g., “under soft moonlight,” “golden-hour glow”).
Use R2V for character-based storytelling; Interpolation for smooth transitions.
Avoid conflicting instructions (e.g., “fast zoom” and “slow motion” together).

Notes & Limitations

Generation time: ~2–3 minutes for an 8-second 1080p clip.
Frame rate fixed at 24 FPS.
Advanced controls (R2V, I2V, Interpolation) are mutually exclusive — only one per generation.
If your prompt is blocked, rewrite it and resubmit (safety thresholds may adjust during preview).

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 Text-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 — Text-to-Video (T2V) 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