Kling v1.6 Image to Video

Kling AI Image to Video

Partner Model

Fast Inference

REST API

Try in Console API Docs Examples

Model Information

Response Time~440 sec

StatusActive

Version

0.0.1

Updated20 days ago

Live Demo

Average runtime: ~440 seconds

Input

Configure model parameters

Prompt

Positive text prompt - Cannot exceed 2500 characters

a man is talking

Negative Prompt

Negative text prompt - Cannot exceed 2500 characters

Enter your negative prompt

Duration

Video Length, unit: s (seconds) - Enum values：5，10

Mode

Video generation mode - Enum values: std, pro - std: Standard Mode, which is cost-effective - pro: Professional Mode, generates videos use longer duration but higher quality video output

Last Frame Image

Reference Image - End frame control - Supported image formats include.jpg / .jpeg / .png - The image file size cannot exceed 10MB, and the image resolution should not be less than 300*300px

File upload is currently disabled

JPEGPNGJPG

First Frame Image

Reference Image The image file size cannot exceed 10MB, and the image resolution should not be less than 300*300px, and the aspect ratio of the image should be between 1:2.5 ~ 2.5:1

File upload is currently disabled

Output

View generated results

Result

Preview, share or download your results with a single click.

Each execution costs $0.15 With $1 you can run this model about 6 times.

API Reference

View Full Documentation

Prerequisites

Create an API Key from the Eachlabs Console
Install the required dependencies for your chosen language (e.g., requests for Python)

API Integration Steps

1. Create a Prediction

Send a POST request to create a new prediction. This will return a prediction ID that you'll use to check the result. The request should include your model inputs and API key.

import requests
import time

API_KEY = "YOUR_API_KEY"  # Replace with your API key
HEADERS = {
    "X-API-Key": API_KEY,
    "Content-Type": "application/json"
}

def create_prediction():
    response = requests.post(
        "https://api.eachlabs.ai/v1/prediction/",
        headers=HEADERS,
        json={
            "model": "Kling AI Image to Video",
            "version": "0.0.1",
            "input": {
  "duration": "10",
  "dynamic_masks": "your dynamic masks here",
  "static_mask": "your_file.image/jpg",
  "mode": "PRO",
  "cfg_scale": null,
  "image_tail": "your_file.image/jpeg",
  "image_url": "https://storage.googleapis.com/magicpoint/models/man.png",
  "negative_prompt": "your negative prompt here",
  "prompt": "a man is talking"
}
        }
    )
    prediction = response.json()
    
    if prediction["status"] != "success":
        raise Exception(f"Prediction failed: {prediction}")
    
    return prediction["predictionID"]

2. Get Prediction Result

Poll the prediction endpoint with the prediction ID until the result is ready. The API uses long-polling, so you'll need to repeatedly check until you receive a success status.

def get_prediction(prediction_id):
    while True:
        result = requests.get(
            f"https://api.eachlabs.ai/v1/prediction/{prediction_id}",
            headers=HEADERS
        ).json()
        
        if result["status"] == "success":
            return result
        elif result["status"] == "error":
            raise Exception(f"Prediction failed: {result}")
        
        time.sleep(1)  # Wait before polling again

3. Complete Example

Here's a complete example that puts it all together, including error handling and result processing. This shows how to create a prediction and wait for the result in a production environment.

try:
    # Create prediction
    prediction_id = create_prediction()
    print(f"Prediction created: {prediction_id}")
    
    # Get result
    result = get_prediction(prediction_id)
    print(f"Output URL: {result['output']}")
    print(f"Processing time: {result['metrics']['predict_time']}s")
except Exception as e:
    print(f"Error: {e}")

Additional Information

The API uses a two-step process: create prediction and poll for results
Response time: ~440 seconds
Rate limit: 60 requests/minute
Concurrent requests: 10 maximum
Use long-polling to check prediction status until completion

Overview

Kling v1.6 Image to Video is a model designed to generate high-quality videos from a single image. By providing key parameters such as prompts, duration, and control settings, users can produce smooth and coherent video sequences based on their desired output.

Technical Specifications

Kling v1.6 onverts a ingle image into a video sequence.
Supports dynamic and static masks for localized modifications.
Adjustable configuration settings for precise control over animation.
Provides multiple processing modes for varied quality and speed requirements.

Key Considerations

Higher cfg_scale values might lead to unnatural motion, whereas lower values may reduce coherence with the input prompt.
Using negative_prompt effectively can significantly improve the relevance of the output.
STD mode is optimized for faster processing, while PRO mode focuses on higher quality but requires more computation.
Ensure that image_url and image_tail have similar compositions to maintain smooth transitions.

Legal Information for Kling v1.6 Image to Video

By using this Kling v1.6 Image to Video, you agree to:

Kling Privacy
Kling SERVICE AGREEMENT

Tips & Tricks

image_url: Choose high-quality images with distinct features to enhance motion clarity.
prompt: Be specific about the desired movement and transitions. Avoid vague descriptions.
duration: For short clips (5 seconds), focus on subtle transitions; for longer clips (10 seconds), ensure more dynamic variations.
mode: Use STD for rapid prototyping and PRO for refined outputs.
image_tail: If not provided, the Kling v1.6 Image to Video will generate an automatic fade-out effect.
static_mask & dynamic_masks: These should be used carefully to control which parts of the image remain unchanged or move dynamically.
cfg_scale: Start with a mid-range value (e.g., 0.5) and adjust based on the results. Higher values (close to 1) enforce stronger adherence to prompts.

Capabilities

Transforms static images into smooth, animated video sequences.
Supports direct control over animation parameters such as duration and mode selection.
Kling v1.6 allows refined adjustments using masks and prompts to guide video generation.

What can I use for?

Creating short animated clips from static images for artistic or storytelling purposes.
Generating dynamic content for advertisements or promotional materials.
Enhancing AI-assisted video generation workflows.
Experimenting with creative motion transformations from single images.

Things to be aware of

Apply static_mask selectively to keep some areas stable while allowing others to move.
Experiment with different cfg_scale values to achieve the right balance between creativity and realism.
Use negative_prompt to eliminate unwanted distortions or artifacts in the generated video.
Try both STD and PRO modes to see the difference in processing speed and output quality.
Create a seamless looping animation by carefully adjusting image_tail settings.

Limitations

The Kling v1.6 Image to Video may struggle with extremely abstract or highly complex scene transformations.
Some inconsistencies may occur if image_url and image_tail do not align well.
Negative_prompt effectiveness varies based on the complexity of the scene.

Output Format: MP4

Related AI Models

SadTalker

sadtalker

Image to Video

Pixverse

pixverse

Image to Video

Live Portrait

live-portrait

Image to Video

Magic Animate

magic-animate

Image to Video