What is the turbo speed advantage for image-to-video generation?

Turbo applies fewer refinement passes than standard or Pro modes, so runs finish faster and per-second cost stays lower. Higher tiers add refinement you won't get here. For iteration-heavy workflows, speed usually matters more than that gap.

How does providing a reference image differ from text-to-video in practice?

The photograph defines the visual subject, appearance, composition, and context. The model animates what's already there instead of generating from a description. This produces more predictable visual fidelity to a specific subject, making it preferable when exact appearance matters.

Can I provide both a first frame and a last frame simultaneously?

Yes. Kling v2.5 Turbo Image-to-Video supports both first-frame and last-frame anchoring in the same request. You can define the starting image, ending image, or both endpoints of the generated clip.

Does the turbo tier support the same aspect ratios and resolutions as other tiers?

Yes. Outputs reach up to 1080p at 16:9, 9:16, and 1:1, matching the delivery formats in standard and Pro tiers on the provider.

What access tier is required on AI Gateway?

Video generation is in beta for Pro and Enterprise plans and paid AI Gateway users. Confirm your plan before you build production integrations.

Why choose v2.5 Turbo i2v over v2.6 i2v?

V2.5 Turbo i2v is faster and cheaper when you don't need audio output. V2.6 i2v adds native audio generation and visual quality improvements. Choose v2.6 when synchronized audio is part of your required output.

Kling AI

Kling v2.5 Turbo Image-to-Video

Kling v2.5 Turbo Image-to-Video animates reference images into 1080p video at turbo generation speed, with first/last frame anchoring for controlled transition sequences.

View API reference

Price: $0.04, Per second
Lowest available configuration

Get API key Read the docs

import { experimental_generateVideo as generateVideo } from 'ai';

const result = await generateVideo({
  model: 'klingai/kling-v2.5-turbo-i2v',
  prompt: 'A serene mountain lake at sunrise.'
});

Read docs

Overview Playground Providers API Similar About FAQ

Copy link to headingPlayground

Try out Kling v2.5 Turbo Image-to-Video by Kling AI. Usage is billed to your team at API rates. Free users (those who haven't made a payment) get $5 of credits every 30 days.

Kling v2.5 Turbo Image-to-Video

Images

Add up to 2 images

Prompt

End frame(optional)

Duration5s

Videos to generate

Generate audio

Your generated video will appear here.

Copy link to headingProviders

Route requests across multiple providers. Copy a provider slug to set your preference. Visit the docs for more info. Using a provider means you agree to their terms, listed under Legal.

Provider

Input	Output	Capabilities	ZDR	No Training	Free Tier	Release Date

Kling AI

Legal:Terms•Privacy

$0.04/sec+1 more

09/23/2025

Getting started

Generate videos with Kling v2.5 Turbo Image-to-Video using the experimental_generateVideo function from AI SDK 6 or later. AI Gateway handles routing and polls until the video is ready.

Install the AI SDK (pnpm add ai dotenv), create an API key from the API Keys page, and set it as AI_GATEWAY_API_KEY in your environment. Full setup is covered in the video generation quickstart.

index.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: {
      image: 'https://example.com/cat.png',
      text: 'The cat slowly turns its head and blinks',
    },
    providerOptions: {
      klingai: {
        mode: 'std',
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Top-level parameters

Exercise the supported top-level parameters: prompt.image, prompt.text, and duration.

top-level-params.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: {
      image: 'https://example.com/cat.png',
      text: 'The cat slowly turns its head and blinks',
    },
    duration: 5,
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Parameter	Type	Required	Description
`prompt.image`	`string`	Yes	URL of the image to animate.
`prompt.text`	`string`	Yes	Description of the motion or animation. Max 2500 characters.
`duration`	`5 \| 10`	No	Video length in seconds. 5 or 10 seconds.
`resolution`	`string`	No	Resolution ('1280x720', '1920x1080').
`aspectRatio`	`string`	No	Aspect ratio ('16:9', '9:16', '1:1').
`generateAudio`	`boolean`	No	Generate synchronized audio with the video.
`frameImages`	`Array<{ image: string \| Buffer; frameType: 'first_frame' \| 'last_frame' }>`	No	First and last frames of the clip. A `first_frame` entry replaces `prompt.image` and wins when both are set, and adding a `last_frame` interpolates between the two. Video is not accepted and is ignored with a warning.
`inputReferences`	`Array<string \| Buffer>`	No	Reference images that the model combines into a new scene, which switches the call to reference-to-video. Images only — a video reference is ignored with a warning. Cannot be combined with `prompt.image`, `frameImages`, or `imageTail`.

Input limits

Input	Formats	Sources	Max count	Max size	Limits
Text	—	—	—	—	Up to 2500 characters
Image	jpg, jpeg, png	url, base64, buffer	2	10 MB	≥300px · aspect 2:5–5:2

Provider options

Load the always-compatible KlingAI options under providerOptions.klingai. The mutually exclusive feature controls — first/last frame (frameImages), reference-to-video (inputReferences), motion brush (dynamicMasks / staticMask), cameraControl, and voice/multi-shot — are shown in their own examples below.

provider-options.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: {
      image: 'https://example.com/cat.png',
      text: 'The cat slowly turns its head and blinks',
    },
    duration: 5,
    generateAudio: true,
    providerOptions: {
      klingai: {
        mode: 'pro',
        negativePrompt: 'blurry, low quality',
        watermarkEnabled: true,
        pollIntervalMs: 5000,
        pollTimeoutMs: 600000,
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Pass KlingAI-specific options under providerOptions.klingai in your generateVideo call.

Parameter	Type	Required	Description
`mode`	`'std' \| 'pro'`	No	`'std'` for standard quality. `'pro'` for professional quality. Defaults to `'std'`.
`negativePrompt`	`string`	No	What to avoid in the video. Max 2500 characters.
`voiceList`	`array`	No	Voice IDs for speech. Max 2 voices. Requires `generateAudio: true`. Cannot coexist with `elementList`.
`imageTail`	`string \| Buffer`	No	The last frame (ending image). Same format requirements as `prompt.image`. Legacy alternative to the top-level `frameImages`, used only when `frameImages` is omitted.
`cameraControl.type`	`string`	No	Camera movement type: `'simple'`, `'down_back'`, `'forward_up'`, `'right_turn_forward'`, or `'left_turn_forward'`.
`cameraControl.config`	`object`	No	Movement configuration. Required when `type` is `'simple'`. Set one of `horizontal`, `vertical`, `pan`, `tilt`, `roll`, or `zoom` in range [-10, 10] and leave the others at 0.
`staticMask`	`string`	No	Mask image for areas that should remain static.
`dynamicMasks`	`array`	No	Array of dynamic mask configurations (up to 6). Each has `mask` (image for areas that should move) and `trajectories` (motion path coordinates, 2-77 points for a 5s video).
`watermarkEnabled`	`boolean`	No	Generate a watermarked result alongside the video.
`pollIntervalMs`	`number`	No	How often to check task status. Defaults to `5000`.
`pollTimeoutMs`	`number`	No	Maximum wait time. Defaults to `600000` (10 minutes).

Base64 image encoding

When passing an image as base64 (for example prompt.image), submit only the raw base64 string. Do not include a data:image/png;base64, prefix.

Mutually exclusive features

First/last frame (frameImages), reference-to-video (inputReferences), motion brush (dynamicMasks / staticMask), and camera control (cameraControl) cannot be combined. Use only one of these per request.

The top-level parameters win over their provider-option equivalents: a first_frame in frameImages overrides prompt.image, and a last_frame overrides providerOptions.klingai.imageTail.

Passing inputReferences switches the model to reference-to-video, which ignores prompt.image, frameImages, and imageTail.

voiceList cannot coexist with elementList.

Audio and voice

Set generateAudio: true to enable audio.

Reference voices in your prompt with the <<<voice_1>>> syntax, where the number matches the order of entries in voiceList. You can use up to 2 voices per video, and voice generation requires generateAudio: true.

First and last frame

Generate a video that transitions between a starting and ending image, interpolating the motion between the two. Pass both frames through the top-level frameImages, tagging one first_frame and one last_frame. Mutually exclusive with motion brush and camera control.

first-last-frame.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const firstFrame = fs.readFileSync('start.png');
  const lastFrame = fs.readFileSync('end.png');

  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: 'Smooth transition between the two scenes',
    frameImages: [
      { image: firstFrame, frameType: 'first_frame' },
      { image: lastFrame, frameType: 'last_frame' },
    ],
    providerOptions: {
      klingai: {
        mode: 'pro',
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Reference to video

Combine reference images into a brand-new scene described by your prompt. Passing inputReferences selects reference-to-video, so leave out prompt.image, frameImages, and imageTail — the references guide what the characters look like rather than becoming the video content.

reference-to-video.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: 'The two characters meet and walk together through a sunny park',
    inputReferences: [
      'https://example.com/character-1.png',
      'https://example.com/character-2.png',
    ],
    aspectRatio: '16:9',
    duration: 5,
    providerOptions: {
      klingai: {
        mode: 'std',
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Camera control

Control camera movement during generation. Use a preset movement type or 'simple' with a config that sets one axis (others stay at 0).

camera-control.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: {
      image: 'https://example.com/landscape.png',
      text: 'A serene mountain landscape',
    },
    providerOptions: {
      klingai: {
        mode: 'std',
        cameraControl: {
          type: 'simple',
          config: {
            zoom: 5,
            horizontal: 0,
            vertical: 0,
            pan: 0,
            tilt: 0,
            roll: 0,
          },
        },
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Motion brush

Control which parts of the image move and how using mask images. Mutually exclusive with first/last frame and camera control.

motion-brush.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: {
      image: 'https://example.com/scene.png',
      text: 'A ball bouncing across the scene',
    },
    providerOptions: {
      klingai: {
        mode: 'std',
        dynamicMasks: [
          {
            mask: 'https://example.com/ball-mask.png',
            trajectories: [
              { x: 100, y: 200 },
              { x: 200, y: 300 },
              { x: 300, y: 200 },
              { x: 400, y: 300 },
            ],
          },
        ],
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Voice generation

Add speech using voice IDs. Requires generateAudio: true. Reference voices in the prompt with the <<<voice_1>>> syntax.

voice-generation.ts

import { experimental_generateVideo as generateVideo } from 'ai';
import fs from 'node:fs';
import 'dotenv/config';

async function main() {
  const result = await generateVideo({
    model: 'klingai/kling-v2.5-turbo-i2v',
    prompt: {
      image: 'https://example.com/person.png',
      text: 'The person<<<voice_1>>> says: "Hello, welcome to my channel"',
    },
    generateAudio: true,
    providerOptions: {
      klingai: {
        mode: 'std',
        voiceList: [{ voiceId: 'your_voice_id' }],
      },
    },
  });

  // Save the generated video
  fs.writeFileSync('output.mp4', result.videos[0].uint8Array);

  console.log('Video saved to output.mp4');
}

main().catch(console.error);

Copy link to headingMore models by Kling AI

Model

Context	Latency	Throughput	Input	Output	Cache	Web Search	Capabilities	Providers	ZDR	No Training	Free Tier	Release Date

klingai/kling-v3.0-motion-control

—

$0.13/sec+1 more

—

03/04/2026

klingai/kling-v3.0-i2v

—

$0.17/sec+1 more

—

02/05/2026

klingai/kling-v2.6-motion-control

—

$0.07/sec+1 more

—

12/18/2025

klingai/kling-v2.6-i2v

—

$0.04/sec+1 more

—

12/03/2025

klingai/kling-v2.6-t2v

—

$0.04/sec+1 more

—

12/03/2025

klingai/kling-v2.5-turbo-t2v

—

$0.04/sec+1 more

—

09/23/2025

Copy link to headingAbout Kling v2.5 Turbo Image-to-Video

Kling v2.5 Turbo Image-to-Video animates a still image into a video clip. It uses the visual content of the reference image and an optional text prompt describing motion or scene atmosphere. The turbo speed tier applies fewer refinement passes than standard or Pro modes, so it reaches results faster at lower per-second cost. Choose this tradeoff when you're testing many animation variants from the same source imagery, or when time-to-first-result is a design constraint.

The image input anchors the visual identity of the output. Unlike text-to-video, where visual content generates entirely from a description, image-to-video starts from an existing visual state (a product, a character, a scene) and animates it forward. V2.5 Turbo i2v fits e-commerce product animation, social media content from brand photography, and any application where the visual subject is already defined.

First-frame and last-frame anchoring extend this control further. You can define both the opening and closing visual states of the clip, and the model generates the motion path connecting them. This fits predictable transition sequences (product reveals, character entrances, or state changes) where you've defined the start and end frames in advance.

The model supports durations of five or 10 seconds and three aspect ratios at up to 1080p when you use Pro mode on the provider, covering standard web and mobile delivery formats without upscaling.

Copy link to headingWhat To Consider When Choosing a Provider

Configuration: Video generation is in beta for Pro and Enterprise plans and paid AI Gateway users. Confirm your plan before you ship.
Zero Data Retention: Zero Data Retention is offered on a per-provider and model basis. See the documentation for details.
Authentication: AI Gateway authenticates requests using an API key or OIDC token. You do not need to manage provider credentials directly.

Copy link to headingWhen to Use Kling v2.5 Turbo Image-to-Video

Best for

Rapid iteration: Testing multiple motion interpretations of the same reference image before committing to a final version
E-commerce product animation: Animating still photography at volume, where turbo speed reduces per-asset generation time
Social short-form video: Producing social media clips from existing brand or product imagery
Defined-endpoint transitions: Sequences where first/last frame anchoring gives predictable control over start and end visual states

Consider alternatives when

Maximum refinement needed: You prefer peak quality over speed, so standard or Pro tiers that apply more passes fit better
Native audio required: You need audio output alongside video, which is a v2.6 feature
Text-driven visuals: The visual content should come from a text description rather than an existing image, so use the t2v variant

Copy link to headingConclusion

Kling v2.5 Turbo Image-to-Video provides the fastest path from reference image to animated video clip in the v2.5 generation. First/last frame control enables predictable transitions. Turbo speed supports the iteration pace that volume-oriented image animation workflows need.

Copy link to headingFrequently Asked Questions

What is the turbo speed advantage for image-to-video generation?
Turbo applies fewer refinement passes than standard or Pro modes, so runs finish faster and per-second cost stays lower. Higher tiers add refinement you won't get here. For iteration-heavy workflows, speed usually matters more than that gap.
How does providing a reference image differ from text-to-video in practice?
The photograph defines the visual subject, appearance, composition, and context. The model animates what's already there instead of generating from a description. This produces more predictable visual fidelity to a specific subject, making it preferable when exact appearance matters.
Can I provide both a first frame and a last frame simultaneously?
Yes. Kling v2.5 Turbo Image-to-Video supports both first-frame and last-frame anchoring in the same request. You can define the starting image, ending image, or both endpoints of the generated clip.
Does the turbo tier support the same aspect ratios and resolutions as other tiers?
Yes. Outputs reach up to 1080p at 16:9, 9:16, and 1:1, matching the delivery formats in standard and Pro tiers on the provider.
What access tier is required on AI Gateway?
Video generation is in beta for Pro and Enterprise plans and paid AI Gateway users. Confirm your plan before you build production integrations.
Why choose v2.5 Turbo i2v over v2.6 i2v?
V2.5 Turbo i2v is faster and cheaper when you don't need audio output. V2.6 i2v adds native audio generation and visual quality improvements. Choose v2.6 when synchronized audio is part of your required output.

Your use is subject to Kling AI's Terms & Privacy Policies.

Agent Stack

Core Platform

Tools

Learn

Build

Explore

Kling v2.5 Turbo Image-to-Video

Copy link to headingPlayground

Copy link to headingProviders

Getting started

Top-level parameters

Input limits

Provider options

Base64 image encoding

Mutually exclusive features

Audio and voice

First and last frame

Reference to video

Camera control

Motion brush

Voice generation

Copy link to headingMore models by Kling AI

Copy link to headingAbout Kling v2.5 Turbo Image-to-Video

Copy link to headingWhat To Consider When Choosing a Provider

Copy link to headingWhen to Use Kling v2.5 Turbo Image-to-Video

Best for

Consider alternatives when

Copy link to headingConclusion

Copy link to headingFrequently Asked Questions

Advanced

Getting started

Top-level parameters

Input limits

Provider options

Base64 image encoding

Mutually exclusive features

Audio and voice

First and last frame

Reference to video

Camera control

Motion brush

Voice generation

Best for

Consider alternatives when

Copy link to headingFrequently Asked Questions