google/veo3.1-lite/start-end-frame-to-video

immagine-in-video

Veo 3.1 Lite Start-End Frame-to-Video API by Google

google/veo3.1-lite/start-end-frame-to-video

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.

INPUT

Prompt *

Immagine *

Puoi trascinare un file qui o fare clic per caricarlo

MAX:1

Ultimo fotogramma *

Puoi trascinare un file qui o fare clic per caricarlo

MAX:1

Proporzioni

Durata

Risoluzione

Seed

OUTPUT

In attesa

I video generati appariranno qui

Configura le impostazioni e clicca Esegui per iniziare

La tua richiesta costerà $0.05 per esecuzione. Con $10 puoi eseguire questo modello circa 200 volte.

Ecco cosa puoi fare dopo:

Seedance 2.0 Kling v3 Vidu Wan2.7

Parametri

Esempio di codice
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-lite/start-end-frame-to-video",  # Required. model name
    "prompt": "A beautiful sunset over the ocean with gentle waves",  # Required. Text description for the video between the first and last frames
    "image": "example_value",  # Required. First frame of the video (instance image)
    "last_image": "example_value",  # Required. Final frame for interpolation (config lastFrame)
    "aspect_ratio": "16:9",  # The aspect ratio of the generated video. options: 16:9 | 9:16
    "duration": 8,  # Length of the generated video in seconds (durationSeconds). options: 4 | 6 | 8
    "resolution": "720p",  # Output resolution. options: 720p | 1080p
    "seed": -1,  # Random seed
}

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()

Installa

Installa il pacchetto di dipendenze richiesto.

pip install requests

Autenticazione

Tutte le richieste API richiedono l'autenticazione tramite una chiave API. Puoi ottenere la tua chiave API dalla dashboard di Atlas Cloud.

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

Header HTTP

import os

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

Proteggi la tua chiave API

Non esporre mai la tua chiave API nel codice lato client o nei repository pubblici. Utilizza invece variabili d'ambiente o un proxy backend.

Invia una richiesta

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())

Invia una richiesta

Invia una richiesta di generazione asincrona. L'API restituisce un ID di previsione che puoi usare per controllare lo stato e recuperare il risultato.

POST/api/v1/model/generateVideo

Corpo della richiesta

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-lite/start-end-frame-to-video",
    "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['data']['id']}")
print(f"Status: {result['data']['status']}")

Risposta

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

Controlla lo stato

Interroga l'endpoint di previsione per verificare lo stato attuale della tua richiesta.

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

Esempio di polling

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)

Valori di stato

processingLa richiesta è ancora in fase di elaborazione.

completedGenerazione completata. Gli output sono disponibili.

succeededGenerazione riuscita. Gli output sono disponibili.

failedLa generazione è fallita. Controlla il campo errore.

Risposta completata

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

Carica file

Carica file nello storage Atlas Cloud e ottieni un URL utilizzabile nelle tue richieste API. Usa multipart/form-data per il caricamento.

POST/api/v1/model/uploadMedia

Esempio di caricamento

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}")

Risposta

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

Schema di input

I seguenti parametri sono accettati nel corpo della richiesta.

Totale: 8Obbligatorio: 4Opzionale: 4

modelstringrequired

model name

Default: "google/veo3.1-lite/start-end-frame-to-video"

promptstringrequired

Text description for the video between the first and last frames. Supports audio cues per Veo prompt guidance.

imagestringrequired

First frame of the video (instance image). Must be used together with last_image (lastFrame in the API). Accepts a public image URL, a data URL, or raw base64-encoded image bytes. Input image up to 8MB per Veo 3.1 Lite limits.

last_imagestringrequired

Final frame for interpolation (config lastFrame). Must be used together with image. Accepts a public image URL, a data URL, or raw base64-encoded image bytes. Input image up to 8MB per Veo 3.1 Lite limits.

aspect_ratiostring

The aspect ratio of the generated video

Default: "16:9"

16:99:16

durationinteger

Length of the generated video in seconds (durationSeconds).

Default: 8

468

resolutionstring

Output resolution. 1080p only supports 8s duration. Veo 3.1 Lite does not support 4K.

Default: "720p"

720p1080p

seedinteger

Random seed. Does not guarantee determinism but may improve repeatability. -1 means a random seed will be used.

Default: -1

Esempio di corpo della richiesta

{
  "model": "google/veo3.1-lite/start-end-frame-to-video",
  "prompt": "A beautiful landscape",
  "image": "example_image",
  "last_image": "example_last_image",
  "aspect_ratio": "16:9",
  "duration": 8,
  "resolution": "720p",
  "seed": -1
}

Schema di output

L'API restituisce una risposta di previsione con gli URL degli output generati.

created_atstring

ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).

idstring

Unique identifier for the prediction, the ID of the prediction to get.

modelstring

Model ID used for the prediction.

outputsarray

Array of URLs to the generated content (empty when status is not completed).

statusstring

Status of the task: created, processing, completed, or failed.

Esempio di risposta

{
  "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 integra oltre 400 modelli di IA direttamente nel tuo assistente di codifica IA. Un comando per installare, poi usa il linguaggio naturale per generare immagini, video e chattare con LLM.

Client supportati

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ client supportati

Installa

npx skills add AtlasCloudAI/atlas-cloud-skills

Configura chiave API

Ottieni la tua chiave API dalla dashboard di Atlas Cloud e impostala come variabile d'ambiente.

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

Funzionalità

Una volta installato, puoi usare il linguaggio naturale nel tuo assistente IA per accedere a tutti i modelli Atlas Cloud.

Generazione di immaginiGenera immagini con modelli come Nano Banana 2, Z-Image e altri.

Creazione di videoCrea video da testo o immagini con Kling, Vidu, Veo, ecc.

Chat LLMChatta con Qwen, DeepSeek e altri grandi modelli linguistici.

Caricamento mediaCarica file locali per la modifica di immagini e flussi di lavoro da immagine a video.

Scopri di più

github.com/AtlasCloudAI/atlas-cloud-skills

Server MCP

Il server MCP di Atlas Cloud collega il tuo IDE con oltre 400 modelli di IA tramite il Model Context Protocol. Funziona con qualsiasi client compatibile MCP.

Client supportati

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ client supportati

Installa

npx -y atlascloud-mcp

Configurazione

Aggiungi la seguente configurazione al file delle impostazioni MCP del tuo IDE.

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

Strumenti disponibili

atlas_generate_imageGenera immagini da prompt testuali.

atlas_generate_videoCrea video da testo o immagini.

atlas_chatChatta con grandi modelli linguistici.

atlas_list_modelsEsplora oltre 400 modelli di IA disponibili.

atlas_quick_generateCreazione di contenuti in un solo passaggio con selezione automatica del modello.

atlas_upload_mediaCarica file locali per i flussi di lavoro API.

Scopri di più

github.com/AtlasCloudAI/mcp-server

API Schema

{
  "info": {
    "title": "AtlasCloud API",
    "version": "1.0.0",
    "description": "The AtlasCloud API."
  },
  "openapi": "3.0.0",
  "paths": {
    "/api/v1/model/generateVideo": {
      "post": {
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/Input"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "The request status."
          }
        }
      },
      "x-api-name": "model_run"
    },
    "/api/v1/model/prediction/{request_id}": {
      "get": {
        "parameters": [
          {
            "in": "path",
            "name": "request_id",
            "required": true,
            "schema": {
              "description": "Request ID",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/PredictionResponse"
                }
              }
            },
            "description": "Result of the request."
          }
        }
      },
      "x-api-name": "model_result"
    }
  },
  "components": {
    "schemas": {
      "Input": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "google/veo3.1-lite/start-end-frame-to-video"
          },
          "prompt": {
            "description": "Text description for the video between the first and last frames. Supports audio cues per Veo prompt guidance.",
            "type": "string"
          },
          "image": {
            "description": "First frame of the video (instance image). Must be used together with last_image (lastFrame in the API). Accepts a public image URL, a data URL, or raw base64-encoded image bytes. Input image up to 8MB per Veo 3.1 Lite limits.",
            "type": "string",
            "x-ui-component": "uploader"
          },
          "last_image": {
            "description": "Final frame for interpolation (config lastFrame). Must be used together with image. Accepts a public image URL, a data URL, or raw base64-encoded image bytes. Input image up to 8MB per Veo 3.1 Lite limits.",
            "type": "string",
            "x-ui-component": "uploader"
          },
          "aspect_ratio": {
            "default": "16:9",
            "description": "The aspect ratio of the generated video",
            "enum": [
              "16:9",
              "9:16"
            ],
            "type": "string",
            "x-ui-component": "select"
          },
          "duration": {
            "default": 8,
            "description": "Length of the generated video in seconds (durationSeconds).",
            "enum": [
              4,
              6,
              8
            ],
            "type": "integer",
            "x-ui-component": "select"
          },
          "resolution": {
            "default": "720p",
            "description": "Output resolution. 1080p only supports 8s duration. Veo 3.1 Lite does not support 4K.",
            "enum": [
              "720p",
              "1080p"
            ],
            "type": "string",
            "x-ui-component": "select"
          },
          "seed": {
            "default": -1,
            "description": "Random seed. Does not guarantee determinism but may improve repeatability. -1 means a random seed will be used.",
            "type": "integer"
          }
        },
        "required": [
          "model",
          "prompt",
          "image",
          "last_image"
        ],
        "type": "object",
        "x-order-properties": [
          "model",
          "prompt",
          "image",
          "last_image",
          "aspect_ratio",
          "duration",
          "resolution",
          "seed"
        ],
        "allOf": [
          {
            "description": "When resolution is 1080p, duration must be 8 (seconds).",
            "if": {
              "properties": {
                "resolution": {
                  "enum": [
                    "1080p"
                  ]
                }
              },
              "required": [
                "resolution"
              ]
            },
            "then": {
              "properties": {
                "duration": {
                  "enum": [
                    8
                  ]
                }
              }
            }
          }
        ]
      },
      "PredictionResponse": {
        "properties": {
          "created_at": {
            "description": "ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).",
            "format": "date-time",
            "type": "string"
          },
          "has_nsfw_contents": {
            "description": "Array of boolean values indicating NSFW detection for each output.",
            "items": {
              "type": "boolean"
            },
            "type": "array"
          },
          "id": {
            "description": "Unique identifier for the prediction, the ID of the prediction to get.",
            "type": "string"
          },
          "model": {
            "description": "Model ID used for the prediction.",
            "type": "string"
          },
          "outputs": {
            "description": "Array of URLs to the generated content (empty when status is not completed).",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "status": {
            "description": "Status of the task: created, processing, completed, or failed.",
            "type": "string"
          },
          "urls": {
            "description": "Object containing related API endpoints.",
            "type": "object"
          }
        },
        "type": "object"
      }
    },
    "securitySchemes": {
      "apiKeyAuth": {
        "in": "header",
        "name": "Authorization",
        "type": "apiKey"
      }
    }
  },
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ]
}

Template di prompt ottimizzato per LLM

# google/veo3.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.


## Overview

- **Submit endpoint (POST)**: `https://api.atlascloud.ai/api/v1/model/generateVideo` — start an async generation; returns a `prediction_id`
- **Poll endpoint (GET)**: `https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}` — poll this until the prediction finishes
- **Model ID**: `google/veo3.1-lite/start-end-frame-to-video`


## API Information

This model can be used via our HTTP API or more conveniently via our client libraries.
See the input and output schema below, as well as the usage examples.


### Input Schema

The API accepts the following input parameters:

- **`model`** (`string`, _required_):
  model name
  - Default: `"google/veo3.1-lite/start-end-frame-to-video"`

- **`prompt`** (`string`, _required_):
  Text description for the video between the first and last frames. Supports audio cues per Veo prompt guidance.

- **`image`** (`string`, _required_):
  First frame of the video (instance image). Must be used together with last_image (lastFrame in the API). Accepts a public image URL, a data URL, or raw base64-encoded image bytes. Input image up to 8MB per Veo 3.1 Lite limits.

- **`last_image`** (`string`, _required_):
  Final frame for interpolation (config lastFrame). Must be used together with image. Accepts a public image URL, a data URL, or raw base64-encoded image bytes. Input image up to 8MB per Veo 3.1 Lite limits.

- **`aspect_ratio`** (`string`, _optional_):
  The aspect ratio of the generated video
  - Default: `"16:9"`
  - Options: "16:9", "9:16"

- **`duration`** (`integer`, _optional_):
  Length of the generated video in seconds (durationSeconds).
  - Default: `8`
  - Options: 4, 6, 8

- **`resolution`** (`string`, _optional_):
  Output resolution. 1080p only supports 8s duration. Veo 3.1 Lite does not support 4K.
  - Default: `"720p"`
  - Options: "720p", "1080p"

- **`seed`** (`integer`, _optional_):
  Random seed. Does not guarantee determinism but may improve repeatability. -1 means a random seed will be used.
  - Default: `-1`



**Required Parameters Example**:

```json
{
  "model": "google/veo3.1-lite/start-end-frame-to-video",
  "prompt": "",
  "image": "",
  "last_image": ""
}
```


**Full Example**:

```json
{
  "model": "google/veo3.1-lite/start-end-frame-to-video",
  "prompt": "",
  "image": "",
  "last_image": "",
  "aspect_ratio": "16:9",
  "duration": 8,
  "resolution": "720p",
  "seed": -1
}
```


### Output Schema

The API returns the following output format:


- **`created_at`** (`string`, _optional_):
  ISO timestamp of when the request was created (e.g., “2023-04-01T12:34:56.789Z”).

- **`has_nsfw_contents`** (`array[boolean]`, _optional_):
  Array of boolean values indicating NSFW detection for each output.

- **`id`** (`string`, _optional_):
  Unique identifier for the prediction, the ID of the prediction to get.

- **`model`** (`string`, _optional_):
  Model ID used for the prediction.

- **`outputs`** (`array[string]`, _optional_):
  Array of URLs to the generated content (empty when status is not completed).

- **`status`** (`string`, _optional_):
  Status of the task: created, processing, completed, or failed.

- **`urls`** (`object`, _optional_):
  Object containing related API endpoints.



**Example Response**:

```json
{
  "created_at": "",
  "has_nsfw_contents": [],
  "id": "",
  "model": "",
  "outputs": [
    ""
  ],
  "status": "",
  "urls": {}
}
```


## Usage Examples

### cURL

```bash
# Step 1: Start generation (async)
curl -X POST "https://api.atlascloud.ai/api/v1/model/generateVideo" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "google/veo3.1-lite/start-end-frame-to-video",
  "prompt": "",
  "image": "",
  "last_image": "",
  "aspect_ratio": "16:9",
  "duration": 8,
  "resolution": "720p",
  "seed": -1
}'

# Response will contain: {"code": 200, "data": {"id": "prediction_id", "status": "processing"}}

# Step 2: Poll for result (replace {prediction_id} with the id returned above)
curl -X GET "https://api.atlascloud.ai/api/v1/model/prediction/{prediction_id}" \
  -H "Authorization: Bearer $ATLASCLOUD_API_KEY"

# Keep polling until status is "completed", "succeeded" or "failed"
# When completed, outputs will contain the generated content URL(s)
```

## Additional Resources

### Documentation

- [Model Playground](https://www.atlascloud.ai/models/google/veo3.1-lite/start-end-frame-to-video)

A supercar executes a breathtaking high-speed drift across the asphalt track, massive tire smoke swirling behind, glowing brake discs, motion blur emphasizing extreme speed, low-angle cinematic camera following the slide, ultra-realistic, high-energy racing scene.

Caricamento...

Google Veo 3.1 Lite — Start–End Frame to Video

Veo 3.1 Lite Preview (veo-3.1-lite-generate-preview) is Google's high-efficiency video model for creators and enterprises that need a programmable, scalable path from still frames to motion. It inherits Veo 3.1–class fidelity and control while emphasizing developer-first integration and competitive pricing at scale. Output is video with audio. The model page notes that Veo 3.1 Lite Preview does not support 4K outputs or Extension; see Video generation for broader capability coverage.

Overview

Generate videos by animating between a first and last frame using Google's Veo 3.1 Lite model.

A lightweight, cost-effective variant of Veo 3.1 that always generates video with audio.

Supported options

The model supports:

Input images up to 8MB in size
720p or 1080p output resolution
8 second duration
16:9 or 9:16 aspect ratio
Audio is always generated
Safety filters are applied to both input images and generated content

Veo 3.1 Lite Start-End Frame-to-Video API by Google

INPUT

OUTPUT

Parametri

Esempio di codice

Installa

Autenticazione

Header HTTP

Invia una richiesta

Invia una richiesta

Corpo della richiesta

Risposta

Controlla lo stato

Esempio di polling

Valori di stato

Risposta completata

Carica file

Esempio di caricamento

Risposta

Schema di input

Esempio di corpo della richiesta

Schema di output

Esempio di risposta

Atlas Cloud Skills

Client supportati

Installa

Configura chiave API

Funzionalità

Server MCP

Client supportati

Installa

Configurazione

Strumenti disponibili

API Schema

Template di prompt ottimizzato per LLM

Google Veo 3.1 Lite — Start–End Frame to Video

Overview

Supported options

Reference

Esplora Modelli Simili

Gemini Omni Flash Reference-to-Video

Gemini Omni Flash Image-to-Video

Gemini Omni Flash Video Edit

Gemini Omni Flash Text-to-Video

Gemini Omni Flash Reference-to-Video Developer

Gemini Omni Flash Image-to-Video Developer

Gemini Omni Flash Text-to-Video Developer

Veo 3.1 Lite Text-to-video

Veo 3.1 Lite Image-to-video

Veo3.1 Fast Image-to-video

Veo3.1 Fast Text-to-video

Veo3.1 Image-to-video

Veo3.1 Reference-to-video

Veo3.1 Text-to-video

Sync.so Lipsync v3

VEED Lipsync

Un'unica API per tutta l'IA multimediale.

Join our Discord community

INPUT

OUTPUT

Parametri

Esempio di codice

Installa

Autenticazione

Header HTTP

Invia una richiesta

Invia una richiesta

Corpo della richiesta

Risposta

Controlla lo stato

Esempio di polling

Valori di stato

Risposta completata

Carica file

Esempio di caricamento

Risposta

Schema di input

Esempio di corpo della richiesta

Schema di output

Esempio di risposta