kwaivgi/kling-v3.0-4k/image-to-video

Bild-zu-Video

Kling v3.0 4K Image-to-Video API by Kuaishou

kwaivgi/kling-v3.0-4k/image-to-video

Image-to-video

Kling v3.0 4K Image-to-Video model by Kuaishou. High-quality video generation from images.

Modelle vergleichen

Kling v3.0 4K Image-to-Video wurde von Kuaishou entwickelt. Atlas Cloud (betrieben von Atlas Cloud AI LLC) stellt lediglich den Zugang bereit und ist nicht Eigentümerin des Modells. Alle Marken sind Eigentum ihrer jeweiligen Inhaber.

Eingabe

Prompt

Tippe @, um Motive zu referenzieren.

Negativ-Prompt

Tippe @, um Motive zu referenzieren.

Bild *

Sie können Dateien hier ablegen oder zum Hochladen klicken

MAX:1

Endbild

Sie können Dateien hier ablegen oder zum Hochladen klicken

MAX:1

Multi-Shot

Dauer

Erweiterte Einstellungen

Ausgabe

Inaktiv

Ihre generierten Videos erscheinen hier

Konfigurieren Sie Parameter und klicken Sie auf Ausführen, um mit der Generierung zu beginnen

Jede Ausführung kostet $0.357. Für $10 können Sie ca. 28 Mal ausführen.

Sie können fortfahren mit:

Seedance 2.0 Kling v3 Vidu Wan2.7

Parameter

Codebeispiel
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": "kwaivgi/kling-v3.0-4k/image-to-video",  # Required. model name
    "cfg_scale": 0.5,  # Flexibility in video generation; The higher the value, the lower the model's degree of flexibility, and the stronger the relevance to the user's prompt. (min: 0, max: 1)
    "duration": 5,  # The duration of the generated media in seconds (3-15)
    "end_image": "example_value",  # URL of the ending image
    "image": "example_value",  # Required. Supported image formats:
    "negative_prompt": "example_value",  # The negative prompt for the generation
    "prompt": "A beautiful sunset over the ocean with gentle waves",  # The positive prompt for the generation
    "sound": True,  # Whether sound is generated simultaneously when generating a video
    "resolution": "1080P",  # The resolution of the generated video
    "multi_shot": False,  # Whether to enable multi-shot generation
    "shot_type": "example_value",  # Multi-shot mode. options: customize | intelligence
    "multi_prompt": [
        {
            "prompt": "example_prompt",
            "duration": 1
        }
    ],  # Per-shot storyboards
    "elements": [
        {
            "reference_type": "image_refer",
            "frontal_image": "example_frontal_image",
            "refer_images": [
                "https://example.com/image1.jpg"
            ],
            "refer_videos": [
                "https://example.com/image1.jpg"
            ],
            "element_name": "example_element_name",
            "element_description": "example_element_description",
            "element_id": 0
        }
    ],  # Subject references (Atlas naming; maps to Kling 'element_list')
}

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

Installieren

Installieren Sie das erforderliche Paket für Ihre Programmiersprache.

pip install requests

Authentifizierung

Alle API-Anfragen erfordern eine Authentifizierung über einen API-Schlüssel. Sie können Ihren API-Schlüssel über das Atlas Cloud Dashboard erhalten.

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

HTTP-Header

import os

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

Schützen Sie Ihren API-Schlüssel

Geben Sie Ihren API-Schlüssel niemals in clientseitigem Code oder öffentlichen Repositories preis. Verwenden Sie stattdessen Umgebungsvariablen oder einen Backend-Proxy.

Anfrage senden

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

Anfrage senden

Senden Sie eine asynchrone Generierungsanfrage. Die API gibt eine Vorhersage-ID zurück, mit der Sie den Status prüfen und das Ergebnis abrufen können.

POST/api/v1/model/generateVideo

Anfragekörper

import requests

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

data = {
    "model": "kwaivgi/kling-v3.0-4k/image-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']}")

Antwort

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

Status prüfen

Fragen Sie den Vorhersage-Endpunkt ab, um den aktuellen Status Ihrer Anfrage zu überprüfen.

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

Abfrage-Beispiel

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)

Statuswerte

processingDie Anfrage wird noch verarbeitet.

completedDie Generierung ist abgeschlossen. Ergebnisse sind verfügbar.

succeededDie Generierung war erfolgreich. Ergebnisse sind verfügbar.

failedDie Generierung ist fehlgeschlagen. Überprüfen Sie das Fehlerfeld.

Abgeschlossene Antwort

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

Dateien hochladen

Laden Sie Dateien in den Atlas Cloud Speicher hoch und erhalten Sie eine URL, die Sie in Ihren API-Anfragen verwenden können. Verwenden Sie multipart/form-data zum Hochladen.

POST/api/v1/model/uploadMedia

Upload-Beispiel

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

Antwort

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

Eingabe-Schema

Die folgenden Parameter werden im Anfragekörper akzeptiert.

Gesamt: 13Erforderlich: 2Optional: 11

modelstringrequired

model name

Default: "kwaivgi/kling-v3.0-4k/image-to-video"

cfg_scalenumber

Flexibility in video generation; The higher the value, the lower the model's degree of flexibility, and the stronger the relevance to the user's prompt.

Default: 0.5Min: 0Max: 1

durationinteger

The duration of the generated media in seconds (3-15).

Default: 5

3456789101112131415

end_imagestring

URL of the ending image.

imagestringrequired

Supported image formats: .jpg/.jpeg/.png. The size of the image file should not exceed 10MB, the width and height of the image should be no less than 300px, and the aspect ratio of the image should be between 1:2.5 and 2.5:1.

negative_promptstring

The negative prompt for the generation.

promptstring

The positive prompt for the generation.

soundboolean

Whether sound is generated simultaneously when generating a video.

Default: true

resolutionstring

The resolution of the generated video.

Default: "1080P"

multi_shotboolean

Whether to enable multi-shot generation.

Default: false

shot_typestring

Multi-shot mode. customize = caller provides per-shot prompts; intelligence = model auto-splits the top-level prompt into shots. Required when multi_shot=true.

customizeintelligence

multi_promptarray[object]

Per-shot storyboards. Required when multi_shot=true and shot_type=customize. Sum of each shot's duration must equal the top-level duration; each shot duration must be >= 1.

Min items: 1Max items: 6

promptstringrequired

Prompt for this shot. Supports subject mentions like <<<element_1>>>.

durationintegerrequired

Duration of this shot in seconds (string, '1'~'15'). Sum of all shots must equal the top-level duration. Each shot duration >= 1.

Min: 1

elementsarray[object]

Subject references (Atlas naming; maps to Kling 'element_list'). Each item either references an existing subject by element_id, or creates a new one inline with element_name + reference_type + frontal_image / refer_images / refer_videos (Atlas wrapper feature — backend creates the element via Kling's element API, then injects the resulting element_id). Mention subjects in prompt with <<<element_N>>> (1-based, matches array position). For kling-v3-omni: up to 3 elements.

Max items: 6

reference_typestring

Reference media type for the new subject (Atlas wrapper).

Default: "image_refer"

image_refervideo_refer

frontal_imagestring

Frontal image URL of the new subject (required when reference_type=image_refer).

refer_imagesarray[string]

Reference image URLs of the new subject (used with reference_type=image_refer).

Max items: 4

refer_videosarray[string]

Reference video URLs of the new subject (used with reference_type=video_refer).

Max items: 4

element_namestring

Name of the new subject to create inline (Atlas wrapper). Mutually exclusive with element_id.

element_descriptionstring

Optional description of the new subject (Atlas wrapper).

element_idinteger

ID of an existing subject from the Kling element library (long / 64-bit integer). Mutually exclusive with element_name.

Beispiel-Anfragekörper

{
  "model": "kwaivgi/kling-v3.0-4k/image-to-video",
  "cfg_scale": 0.5,
  "duration": 5,
  "image": "example_image",
  "sound": true,
  "resolution": "1080P",
  "multi_shot": false
}

Ausgabe-Schema

Die API gibt eine Vorhersage-Antwort mit den generierten Ausgabe-URLs zurück.

created_atstring

ISO timestamp of when the request was created.

idstring

Unique identifier for the prediction.

modelstring

Model ID used for the prediction.

outputsarray

Array of URLs to the generated content.

statusstring

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

Beispielantwort

{
  "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 integriert über 400 KI-Modelle direkt in Ihren KI-Programmierassistenten. Ein Befehl zur Installation, dann generieren Sie per natürlicher Sprache Bilder und Videos und chatten mit LLMs.

Unterstützte Clients

Claude Code

OpenAI Codex

Gemini CLI

Cursor

Windsurf

VS Code

Trae

GitHub Copilot

Cline

Roo Code

Amp

Goose

Replit

40+ unterstützte clients

Installieren

npx skills add AtlasCloudAI/atlas-cloud-skills

API-Schlüssel einrichten

Erhalten Sie Ihren API-Schlüssel über das Atlas Cloud Dashboard und setzen Sie ihn als Umgebungsvariable.

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

Funktionen

Nach der Installation können Sie natürliche Sprache in Ihrem KI-Assistenten verwenden, um auf alle Atlas Cloud Modelle zuzugreifen.

BildgenerierungGenerieren Sie Bilder mit Modellen wie Nano Banana 2, Z-Image und mehr.

VideoerstellungErstellen Sie Videos aus Text oder Bildern mit Kling, Vidu, Veo usw.

LLM-ChatChatten Sie mit Qwen, DeepSeek und anderen großen Sprachmodellen.

Medien-UploadLaden Sie lokale Dateien für Bildbearbeitung und Bild-zu-Video-Workflows hoch.

Mehr erfahren

github.com/AtlasCloudAI/atlas-cloud-skills

MCP-Server

Der Atlas Cloud MCP-Server verbindet Ihre IDE mit über 400 KI-Modellen über das Model Context Protocol. Funktioniert mit jedem MCP-kompatiblen Client.

Unterstützte Clients

Cursor

VS Code

Windsurf

Claude Code

OpenAI Codex

Gemini CLI

Cline

Roo Code

100+ unterstützte clients

Installieren

npx -y atlascloud-mcp

Konfiguration

Fügen Sie die folgende Konfiguration zur MCP-Einstellungsdatei Ihrer IDE hinzu.

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

Verfügbare Werkzeuge

atlas_generate_imageGenerieren Sie Bilder aus Textbeschreibungen.

atlas_generate_videoErstellen Sie Videos aus Text oder Bildern.

atlas_chatChatten Sie mit großen Sprachmodellen.

atlas_list_modelsDurchsuchen Sie über 400 verfügbare KI-Modelle.

atlas_quick_generateInhaltserstellung in einem Schritt mit automatischer Modellauswahl.

atlas_upload_mediaLaden Sie lokale Dateien für API-Workflows hoch.

Mehr erfahren

github.com/AtlasCloudAI/mcp-server

API-Schema

{
  "components": {
    "schemas": {
      "Input": {
        "properties": {
          "model": {
            "type": "string",
            "description": "model name",
            "default": "kwaivgi/kling-v3.0-4k/image-to-video"
          },
          "cfg_scale": {
            "default": 0.5,
            "description": "Flexibility in video generation; The higher the value, the lower the model's degree of flexibility, and the stronger the relevance to the user's prompt.",
            "maximum": 1,
            "minimum": 0,
            "step": 0.01,
            "type": "number",
            "x-ui-component": "slider"
          },
          "duration": {
            "default": 5,
            "description": "The duration of the generated media in seconds (3-15).",
            "enum": [
              3,
              4,
              5,
              6,
              7,
              8,
              9,
              10,
              11,
              12,
              13,
              14,
              15
            ],
            "type": "integer",
            "x-ui-component": "select"
          },
          "end_image": {
            "description": "URL of the ending image.",
            "type": "string",
            "x-accept": "image/*",
            "x-ui-component": "uploader"
          },
          "image": {
            "description": "Supported image formats: .jpg/.jpeg/.png. The size of the image file should not exceed 10MB, the width and height of the image should be no less than 300px, and the aspect ratio of the image should be between 1:2.5 and 2.5:1.",
            "type": "string"
          },
          "negative_prompt": {
            "description": "The negative prompt for the generation.",
            "type": "string"
          },
          "prompt": {
            "description": "The positive prompt for the generation.",
            "type": "string"
          },
          "sound": {
            "description": "Whether sound is generated simultaneously when generating a video.",
            "type": "boolean",
            "default": true
          },
          "resolution": {
            "default": "1080P",
            "description": "The resolution of the generated video.",
            "type": "string"
          },
          "multi_shot": {
            "type": "boolean",
            "description": "Whether to enable multi-shot generation.",
            "default": false
          },
          "shot_type": {
            "type": "string",
            "description": "Multi-shot mode. customize = caller provides per-shot prompts; intelligence = model auto-splits the top-level prompt into shots. Required when multi_shot=true.",
            "enum": [
              "customize",
              "intelligence"
            ],
            "x-ui-component": "select"
          },
          "multi_prompt": {
            "type": "array",
            "description": "Per-shot storyboards. Required when multi_shot=true and shot_type=customize. Sum of each shot's duration must equal the top-level duration; each shot duration must be >= 1.",
            "minItems": 1,
            "maxItems": 6,
            "items": {
              "type": "object",
              "required": [
                "prompt",
                "duration"
              ],
              "properties": {
                "prompt": {
                  "type": "string",
                  "description": "Prompt for this shot. Supports subject mentions like <<<element_1>>>.",
                  "maxLength": 512
                },
                "duration": {
                  "type": "integer",
                  "description": "Duration of this shot in seconds (string, '1'~'15'). Sum of all shots must equal the top-level duration. Each shot duration >= 1.",
                  "minimum": 1
                }
              }
            }
          },
          "elements": {
            "type": "array",
            "description": "Subject references (Atlas naming; maps to Kling 'element_list'). Each item either references an existing subject by element_id, or creates a new one inline with element_name + reference_type + frontal_image / refer_images / refer_videos (Atlas wrapper feature — backend creates the element via Kling's element API, then injects the resulting element_id). Mention subjects in prompt with <<<element_N>>> (1-based, matches array position). For kling-v3-omni: up to 3 elements.",
            "maxItems": 6,
            "items": {
              "type": "object",
              "properties": {
                "reference_type": {
                  "type": "string",
                  "description": "Reference media type for the new subject (Atlas wrapper).",
                  "enum": [
                    "image_refer",
                    "video_refer"
                  ],
                  "default": "image_refer"
                },
                "frontal_image": {
                  "type": "string",
                  "description": "Frontal image URL of the new subject (required when reference_type=image_refer)."
                },
                "refer_images": {
                  "type": "array",
                  "description": "Reference image URLs of the new subject (used with reference_type=image_refer).",
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 4
                },
                "refer_videos": {
                  "type": "array",
                  "description": "Reference video URLs of the new subject (used with reference_type=video_refer).",
                  "items": {
                    "type": "string"
                  },
                  "maxItems": 4
                },
                "element_name": {
                  "type": "string",
                  "description": "Name of the new subject to create inline (Atlas wrapper). Mutually exclusive with element_id."
                },
                "element_description": {
                  "type": "string",
                  "description": "Optional description of the new subject (Atlas wrapper).",
                  "x-hidden": true
                },
                "element_id": {
                  "type": "integer",
                  "description": "ID of an existing subject from the Kling element library (long / 64-bit integer). Mutually exclusive with element_name.",
                  "x-hidden": true
                }
              },
              "allOf": [
                {
                  "if": {
                    "properties": {
                      "reference_type": {
                        "const": "video_refer"
                      }
                    },
                    "required": [
                      "reference_type"
                    ]
                  },
                  "then": {
                    "required": [
                      "refer_videos"
                    ],
                    "properties": {
                      "frontal_image": {
                        "x-hidden": true
                      },
                      "refer_images": {
                        "x-hidden": true
                      },
                      "refer_videos": {
                        "minItems": 1
                      }
                    }
                  },
                  "else": {
                    "required": [
                      "frontal_image",
                      "refer_images"
                    ],
                    "properties": {
                      "refer_videos": {
                        "x-hidden": true
                      },
                      "refer_images": {
                        "minItems": 1
                      }
                    }
                  }
                }
              ]
            }
          }
        },
        "allOf": [
          {
            "if": {
              "properties": {
                "multi_shot": {
                  "const": true
                }
              },
              "required": [
                "multi_shot"
              ]
            },
            "then": {
              "required": [
                "shot_type"
              ]
            },
            "else": {
              "required": [
                "prompt"
              ],
              "properties": {
                "shot_type": {
                  "x-hidden": true
                },
                "multi_prompt": {
                  "x-hidden": true
                }
              }
            }
          },
          {
            "if": {
              "properties": {
                "shot_type": {
                  "const": "customize"
                }
              },
              "required": [
                "shot_type"
              ]
            },
            "then": {
              "required": [
                "multi_prompt"
              ],
              "properties": {
                "prompt": {
                  "x-hidden": true,
                  "x-hidden-hint": "Customize mode uses the per-shot prompts below. Your prompt is saved and reappears when you leave Customize mode."
                }
              }
            }
          },
          {
            "if": {
              "properties": {
                "shot_type": {
                  "const": "intelligence"
                }
              },
              "required": [
                "shot_type"
              ]
            },
            "then": {
              "required": [
                "prompt"
              ],
              "properties": {
                "multi_prompt": {
                  "x-hidden": true
                }
              }
            }
          }
        ],
        "required": [
          "model",
          "image"
        ],
        "type": "object",
        "x-order-properties": [
          "model",
          "prompt",
          "negative_prompt",
          "image",
          "end_image",
          "multi_shot",
          "shot_type",
          "multi_prompt",
          "elements",
          "duration",
          "cfg_scale",
          "sound"
        ]
      },
      "PredictionResponse": {
        "properties": {
          "created_at": {
            "description": "ISO timestamp of when the request was created.",
            "format": "date-time",
            "type": "string"
          },
          "id": {
            "description": "Unique identifier for the prediction.",
            "type": "string"
          },
          "model": {
            "description": "Model ID used for the prediction.",
            "type": "string"
          },
          "outputs": {
            "description": "Array of URLs to the generated content.",
            "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"
      }
    }
  },
  "info": {
    "description": "The AtlasCloud API.",
    "title": "AtlasCloud API",
    "version": "1.0.0"
  },
  "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/result/{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"
    }
  },
  "servers": [
    {
      "url": "https://api.atlascloud.ai"
    }
  ],
  "model": "kwaivgi/kling-v3.0-4k/image-to-video",
  "description": "Kling V3.0 4K Image-to-Video"
}

LLM-freundliche Prompt-Vorlage

# kwaivgi/kling-v3.0-4k/image-to-video

> Kling v3.0 4K Image-to-Video model by Kuaishou. High-quality video generation from images.


## 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**: `kwaivgi/kling-v3.0-4k/image-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: `"kwaivgi/kling-v3.0-4k/image-to-video"`

- **`prompt`** (`string`, _optional_):
  The positive prompt for the generation.

- **`negative_prompt`** (`string`, _optional_):
  The negative prompt for the generation.

- **`image`** (`string`, _required_):
  Supported image formats: .jpg/.jpeg/.png. The size of the image file should not exceed 10MB, the width and height of the image should be no less than 300px, and the aspect ratio of the image should be between 1:2.5 and 2.5:1.

- **`end_image`** (`string`, _optional_):
  URL of the ending image.

- **`multi_shot`** (`boolean`, _optional_):
  Whether to enable multi-shot generation.
  - Default: `false`

- **`shot_type`** (`string`, _optional_):
  Multi-shot mode. customize = caller provides per-shot prompts; intelligence = model auto-splits the top-level prompt into shots. Required when multi_shot=true.
  - Options: "customize", "intelligence"

- **`multi_prompt`** (`array[object]`, _optional_):
  Per-shot storyboards. Required when multi_shot=true and shot_type=customize. Sum of each shot's duration must equal the top-level duration; each shot duration must be >= 1.
  - Min items: 1
  - Max items: 6
  - Item properties:
    - **`prompt`** (`string`, _required_):
      Prompt for this shot. Supports subject mentions like <<<element_1>>>.

    - **`duration`** (`integer`, _required_):
      Duration of this shot in seconds (string, '1'~'15'). Sum of all shots must equal the top-level duration. Each shot duration >= 1.
      - Min: 1


- **`elements`** (`array[object]`, _optional_):
  Subject references (Atlas naming; maps to Kling 'element_list'). Each item either references an existing subject by element_id, or creates a new one inline with element_name + reference_type + frontal_image / refer_images / refer_videos (Atlas wrapper feature — backend creates the element via Kling's element API, then injects the resulting element_id). Mention subjects in prompt with <<<element_N>>> (1-based, matches array position). For kling-v3-omni: up to 3 elements.
  - Max items: 6
  - Item properties:
    - **`reference_type`** (`string`, _optional_):
      Reference media type for the new subject (Atlas wrapper).
      - Default: `"image_refer"`
      - Options: "image_refer", "video_refer"

    - **`frontal_image`** (`string`, _optional_):
      Frontal image URL of the new subject (required when reference_type=image_refer).

    - **`refer_images`** (`array[string]`, _optional_):
      Reference image URLs of the new subject (used with reference_type=image_refer).
      - Max items: 4

    - **`refer_videos`** (`array[string]`, _optional_):
      Reference video URLs of the new subject (used with reference_type=video_refer).
      - Max items: 4

    - **`element_name`** (`string`, _optional_):
      Name of the new subject to create inline (Atlas wrapper). Mutually exclusive with element_id.

    - **`element_description`** (`string`, _optional_):
      Optional description of the new subject (Atlas wrapper).

    - **`element_id`** (`integer`, _optional_):
      ID of an existing subject from the Kling element library (long / 64-bit integer). Mutually exclusive with element_name.


- **`duration`** (`integer`, _optional_):
  The duration of the generated media in seconds (3-15).
  - Default: `5`
  - Options: 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

- **`cfg_scale`** (`number`, _optional_):
  Flexibility in video generation; The higher the value, the lower the model's degree of flexibility, and the stronger the relevance to the user's prompt.
  - Default: `0.5`
  - Min: 0
  - Max: 1

- **`sound`** (`boolean`, _optional_):
  Whether sound is generated simultaneously when generating a video.
  - Default: `true`



**Required Parameters Example**:

```json
{
  "model": "kwaivgi/kling-v3.0-4k/image-to-video",
  "image": ""
}
```


**Full Example**:

```json
{
  "model": "kwaivgi/kling-v3.0-4k/image-to-video",
  "prompt": "",
  "negative_prompt": "",
  "image": "",
  "end_image": "",
  "multi_shot": false,
  "shot_type": "customize",
  "multi_prompt": [
    {
      "prompt": "",
      "duration": 1
    }
  ],
  "elements": [
    {
      "reference_type": "image_refer",
      "frontal_image": "",
      "refer_images": [
        ""
      ],
      "refer_videos": [
        ""
      ],
      "element_name": "",
      "element_description": "",
      "element_id": 0
    }
  ],
  "duration": 5,
  "cfg_scale": 0.5,
  "sound": true
}
```


### Output Schema

The API returns the following output format:


- **`created_at`** (`string`, _optional_):
  ISO timestamp of when the request was created.

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

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

- **`outputs`** (`array[string]`, _optional_):
  Array of URLs to the generated content.

- **`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": "",
  "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": "kwaivgi/kling-v3.0-4k/image-to-video",
  "prompt": "",
  "negative_prompt": "",
  "image": "",
  "end_image": "",
  "multi_shot": false,
  "shot_type": "customize",
  "multi_prompt": [
    {
      "prompt": "",
      "duration": 1
    }
  ],
  "elements": [
    {
      "reference_type": "image_refer",
      "frontal_image": "",
      "refer_images": [
        ""
      ],
      "refer_videos": [
        ""
      ],
      "element_name": "",
      "element_description": "",
      "element_id": 0
    }
  ],
  "duration": 5,
  "cfg_scale": 0.5,
  "sound": true
}'

# 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/kwaivgi/kling-v3.0-4k/image-to-video)

Robot-1<<<element_1>>> looked down at the small Robot-2<<<element_2>>> and reached out to pat its head; Robot-2<<<element_2>>> began to sway happily.

Wird geladen...

Kling V3.0 4K Image-to-Video

Kling V3.0 4K Image-to-Video is Kuaishou's highest-quality image-to-video model. Upload a reference image and describe the motion — the model generates cinematic-grade video with superior visual fidelity, optional synchronized sound and start-to-end frame guidance.

Why Choose This?

4K-tier quality Superior visual detail, motion smoothness, and cinematic rendering compared to Standard.

Start-end frame guidance Optional end image for controlled transitions between two frames.

Sound generation Optional synchronized sound effects generated alongside the video.

CFG scale control Fine-tune the balance between prompt adherence and creative freedom.

Parameters

Parameter	Required	Description
prompt	No	Text description of the desired motion and action
negative_prompt	No	Elements to exclude from generation
image	Yes	Start frame image to animate (URL or upload)
end_image	No	End frame image for guided transitions
duration	No	Video length: 5 or 10 seconds (default: 5)
cfg_scale	No	Prompt adherence strength (default: 0.5)
sound	No	Generate synchronized sound (default: disabled)

How to Use

Run — submit and download your video.
Enable sound (optional) — generate synchronized audio with the video.
Adjust cfg_scale (optional) — higher for stricter prompt following, lower for more freedom.
Set duration — 5 seconds or 10 seconds.
Add negative prompt (optional) — specify what you want to avoid.
Upload end image (optional) — provide an end frame for guided transitions.
Write your prompt (optional) — describe the motion, camera movement, and action.
Upload your image — provide the reference image to animate.

Best Use Cases

Brand Content — Polished visual storytelling from still imagery.
Short Films — Create film-quality animated scenes with dialogue.
Professional Marketing — Premium promotional videos with sound from product photos.
Scene Transitions — Use start and end frames for smooth cinematic transitions.
High-End Photo Animation — Bring images to life with maximum visual quality.

Pro Tips

Use Standard tier for drafts and testing, Pro for final production.
Lower cfg_scale for more creative variation, higher for strict prompt adherence.
Use negative prompts to avoid artifacts (e.g., "blurry, low quality, distorted").
Enable sound for a complete video experience with synchronized audio.
Add an end_image for controlled transitions between two visual states.
Use clear, descriptive prompts with specific motion and cinematography details.

Notes

Ensure uploaded image URLs are publicly accessible.
Duration options are 5 or 10 seconds only.
Image is the only required field; prompt is optional but recommended.

Kling V3.0 Standard Text-to-Video — Standard tier text-to-video.
Kling V3.0 Standard Image-to-Video — Standard tier at lower cost.
Kling V3.0 Pro Text-to-Video — Pro quality text-to-video generation.

Kling V3.0 Turbo Text-to-Video

Kling V3.0 Turbo Text-to-Video generates dynamic cinematic videos from text prompts using MVL technology. Supports first/last frame control and audio generation.

Kling V3.0 Turbo Image-to-Video

Kling V3.0 Turbo Image-to-Video transforms static images into dynamic cinematic videos using MVL technology. Supports first/last frame control and audio generation.

Kling Video O3 4K Text-to-Video

Kling Omni Video O3 (4K) is Kuaishou advanced unified multi-modal video model with MVL (Multi-modal Visual Language) technology. Generates high-quality videos from text prompts with natural motion and audio generation support.

Kling Video O3 4K Image-to-Video

Kling Omni Video O3 (4K) Image-to-Video transforms static images into dynamic cinematic videos using MVL technology. Supports first/last frame control and audio generation.

Kling v3.0 Std Image-to-Video

Kling v3.0 Standard Image-to-Video model by Kuaishou. High-quality video generation from images.

Kling v3.0 Pro Image-to-Video

Kling v3.0 Professional Image-to-Video model by Kuaishou. Premium quality video generation from images with advanced features.

Kling v3.0 Pro Text-to-Video

Kling v3.0 Professional Text-to-Video model by Kuaishou. Premium quality video generation from text prompts with advanced features.

Kling v3.0 4K Text-to-Video

Kling v3.0 4K Text-to-Video model by Kuaishou. High-quality video generation from text prompts.

Kling v3.0 Std Text-to-Video

Kling v3.0 Standard Text-to-Video model by Kuaishou. High-quality video generation from text prompts.

Kling v2.6 Pro Avatar

Kling V2 AI Avatar Pro generates high-quality AI avatar videos with clean detail, stable motion, and strong identity consistency—ideal for profiles, intros, and social content.

Kling v2.6 Std Avatar

Kling AI Avatar generates high-quality AI avatar videos for profiles, intros, and social content, delivering clean detail and cinematic motion with reliable prompt adherence.

Kling v2.6 Pro Motion Control

Kling 2.6 Pro Motion Control turns reference motion clips (dance, action, gesture) into smooth, realistic animations. Upload a character image (or source video) and a motion video; the model transfers the movement while preserving identity and temporal consistency.

Kling v2.6 Std Motion Control

Kling 2.6 Standard Motion Control transfers motion from reference videos to animate still images. Upload a character image and a motion clip (dance, action, gesture), and the model extracts the movement to generate smooth, realistic video.

Kling Video O3 Pro Image-to-Video

Kling Omni Video O3 Image-to-Video transforms static images into dynamic cinematic videos using MVL technology. Professional quality with first/last frame control and audio generation.

Kling Video O3 Pro Text-to-Video

Kling Omni Video O3 is Kuaishou's advanced unified multi-modal video model with MVL (Multi-modal Visual Language) technology. Professional quality with enhanced motion and detail.

Kling Video O3 Pro Video-Edit

Kling Omni Video O3 Video-Edit enables conversational video editing through natural language commands. Professional quality with object removal/replacement, background changes, and effects.

Eine API für alle Media-KI.

Alle Modelle erkunden

Kling v3.0 4K Image-to-Video API by Kuaishou

Eingabe

Ausgabe

Parameter

Codebeispiel

Installieren

Authentifizierung

HTTP-Header

Anfrage senden

Anfrage senden

Anfragekörper

Antwort

Status prüfen

Abfrage-Beispiel

Statuswerte

Abgeschlossene Antwort

Dateien hochladen

Upload-Beispiel

Antwort

Eingabe-Schema

Beispiel-Anfragekörper

Ausgabe-Schema

Beispielantwort

Atlas Cloud Skills

Unterstützte Clients

Installieren

API-Schlüssel einrichten

Funktionen

MCP-Server

Unterstützte Clients

Installieren

Konfiguration

Verfügbare Werkzeuge

API-Schema

LLM-freundliche Prompt-Vorlage

Kling V3.0 4K Image-to-Video

Why Choose This?

Parameters

How to Use

Best Use Cases

Pro Tips

Notes

Related Models

Ähnliche Modelle Erkunden

Kling V3.0 Turbo Text-to-Video

Kling V3.0 Turbo Image-to-Video

Kling Video O3 4K Text-to-Video

Kling Video O3 4K Image-to-Video

Kling v3.0 Std Image-to-Video

Kling v3.0 Pro Image-to-Video

Kling v3.0 Pro Text-to-Video

Kling v3.0 4K Text-to-Video

Kling v3.0 Std Text-to-Video

Kling v2.6 Pro Avatar

Kling v2.6 Std Avatar

Kling v2.6 Pro Motion Control

Kling v2.6 Std Motion Control

Kling Video O3 Pro Image-to-Video

Kling Video O3 Pro Text-to-Video

Kling Video O3 Pro Video-Edit

Eine API für alle Media-KI.

Eingabe

Ausgabe

Parameter

Codebeispiel

Installieren

Authentifizierung

HTTP-Header

Anfrage senden

Anfrage senden

Anfragekörper

Antwort

Status prüfen

Abfrage-Beispiel

Statuswerte

Abgeschlossene Antwort

Dateien hochladen

Upload-Beispiel

Antwort

Eingabe-Schema