Kling 3.0 Turbo Pro Image to Video API

kwaivgi/kling-v3-turbo-pro/image-to-video

Kling 3.0 Turbo Pro Image to Video animates a single first-frame image into 3–15 second 1080p video with deep detail restoration, native audio-visual lip sync, and cinematic camera direction. It preserves the subject identity, composition, and material texture of the source frame while adding natural motion and multi-shot pacing. With multi_prompt, omitting top-level duration also allows shot totals of 1–2 seconds.

Input

Start frame

Add start

Upload the required image.

Prompt

0/2500

Duration

Output

Idle

Your generated video will appear here

Add your prompt and required media, review the settings, then click Run.

Continue with

Kling 3.0 Turbo Standard Text to Video Kling 3.0 Turbo Standard Image to Video Kling 3.0 Turbo Pro Text to Video Kling 3.0

Examples

The elderly man slowly smiles, eyes crinkling warmly, soft lamp light flickering gently

The steam locomotive moves forward across the stone bridge, white smoke billowing and drifting back

A gentle breeze blows, dandelion seeds detach and drift away into the warm evening air

REST API

Quick Start

Authenticate with the API, submit the prompt and settings, then retrieve the video using the task ID.

Connect to the Vidgo API

Create an API key, keep it only on your server, and send Authorization: Bearer VIDGO_API_KEY.

Endpoint: POSThttps://api.vidgo.ai/api/generate/submit
Authentication: Authorization: Bearer VIDGO_API_KEY

Submit one generation task

Fill in the parameters for this endpoint using the request example, then save the returned task_id to query progress and results.

Submit request

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "kwaivgi/kling-v3-turbo-pro/image-to-video",
  "input": {
    "image_urls": [
      "https://cdn.vidgo.ai/apis/models/kwaivgi/kling-v3-turbo-pro/image-to-video/v1/01/input-01.png"
    ],
    "prompt": "The elderly man slowly smiles, eyes crinkling warmly, soft lamp light flickering gently",
    "duration": 5
  }
}
JSON
)

RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

CODE=$(printf '%s' "$RESPONSE" | jq -r '.code // empty')
if [ "$CODE" != "0" ] && [ "$CODE" != "200" ]; then
  printf 'API error: %s
' "$RESPONSE" >&2
  exit 1
fi
printf '%s
' "$RESPONSE"

Wait for the result

Query with task_id, continue for not_started/running, and stop for finished/failed. On success, read data.files[].file_url.

Track status

GET https://api.vidgo.ai/api/generate/status/{task_id}

Poll status with a 2-second base interval, and increase the interval for longer tasks. Continue only while status is not_started or running, and stop once finished or failed. You can also specify callback_url in the request payload to receive webhook notifications.

not_startedrunningfinishedfailed

Submit response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "running",
    "created_time": "2026-09-16T10:00:00Z"
  }
}

Finished response

{
  "code": 200,
  "data": {
    "task_id": "task-unified-...",
    "status": "finished",
    "files": [
      {
        "file_url": "https://storage.vidgo.ai/generated/video.mp4",
        "file_type": "video"
      }
    ],
    "created_time": "2026-08-22T10:00:00Z",
    "progress": 100,
    "error_message": null
  }
}

Complete runnable example

Expand for a complete script with HTTP and business-code checks, task_id validation, polling, terminal-state handling, and a timeout boundary.

Complete runnable example

set -euo pipefail
: "${VIDGO_API_KEY:?Set VIDGO_API_KEY in your environment}"

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "kwaivgi/kling-v3-turbo-pro/image-to-video",
  "input": {
    "image_urls": [
      "https://cdn.vidgo.ai/apis/models/kwaivgi/kling-v3-turbo-pro/image-to-video/v1/01/input-01.png"
    ],
    "prompt": "The elderly man slowly smiles, eyes crinkling warmly, soft lamp light flickering gently",
    "duration": 5
  }
}
JSON
)

SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data "$REQUEST_BODY")

TASK_ID=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.data.task_id // .task_id // empty')
BUSINESS_CODE=$(printf '%s' "$SUBMIT_RESPONSE" | jq -r '.code // empty')
if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
  printf 'Submit failed:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi
if [ -z "$TASK_ID" ]; then
  printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi

START_TIME=$(date +%s)
POLL_DELAY=2
while true; do
  if [ $(( $(date +%s) - START_TIME )) -ge 600 ]; then
    printf 'Timed out after 600 seconds
' >&2
    exit 1
  fi
  STATUS_RESPONSE=$(curl --silent --show-error --fail-with-body \
    --url "https://api.vidgo.ai/api/generate/status/$TASK_ID" \
    --header "Authorization: Bearer $VIDGO_API_KEY")
  STATUS=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.data.status // .status // empty')
  BUSINESS_CODE=$(printf '%s' "$STATUS_RESPONSE" | jq -r '.code // empty')
  if [ "$BUSINESS_CODE" != "0" ] && [ "$BUSINESS_CODE" != "200" ]; then
    printf 'Status request failed:
%s
' "$STATUS_RESPONSE" >&2
    exit 1
  fi

  case "$STATUS" in
    finished)
      printf '%s' "$STATUS_RESPONSE" | jq -r '(.data.files // .files // [])[]?.file_url'
      break
      ;;
    failed)
      printf '%s' "$STATUS_RESPONSE" | jq -r '.data.error_message // .error_message // "Generation failed"' >&2
      exit 1
      ;;
    not_started|running)
      sleep "$POLL_DELAY"
      if [ "$POLL_DELAY" -lt 10 ]; then POLL_DELAY=$((POLL_DELAY + 1)); fi
      ;;
    *)
      printf 'Unexpected task status: %s
' "$STATUS" >&2
      exit 1
      ;;
  esac
done

Input parameters

The table lists available input parameters, types, and defaults. Request examples also include the required top-level model field.

Field	Type	Required	Default	Description
image_urls	array	Yes	—	Exactly one public image URL used as the first frame.
prompt	string	No	—	1–2500 characters. Mutually exclusive with multi_prompt.
duration	integer	No	Shot total / 5	An explicit duration must be 3–15 seconds and equal the shot total when multi_prompt is set. Omit it to use the shot total (1–15 seconds); without multi_prompt it defaults to 5 seconds.
multi_prompt	array	No	—	1–6 shots, each with a nonblank prompt and optional duration of 1–15 seconds (default 5). Total duration must not exceed 15 seconds. Mutually exclusive with a nonblank prompt.
multi_prompt[].prompt	string	Yes (if multi_prompt is set)	—	Shot prompt, max 2500 characters.
multi_prompt[].duration	integer	No	5	Shot duration from 1 to 15 seconds.
aspect_ratio	string	No	—	The output aspect ratio follows the input image; aspect_ratio has no effect on this endpoint.

Response Fields

A successful submission returns a task ID. Status queries provide progress, output files, and error details when a task fails.

Field	Type	Description
code	integer	Application result code; successful responses use 0 or 200.
message	string	Human-readable message or error detail when present.
data.task_id	string	Task ID used in the status endpoint path.
data.status	string	not_started, running, finished, or failed.
data.created_time	string	Task creation time in date-time format.
data.progress	integer	Task progress from 0 to 100, when included in the response.
data.files[]	array	All output files from a successful task, in response order.
data.files[].file_url	string	Public URL for a generated video.
data.files[].file_type	string	File type, such as video.
data.error_message	string \| null	Failure detail when status is failed.

Task Lifecycle

Continue querying while the status is not_started or running. End polling at finished or failed, then process the output files or error details respectively.

not_started
The task was accepted and is waiting to begin.
running
Generation is in progress. Continue polling the same task_id.
finished
Generation succeeded. Read every video URL from data.files[].file_url.
failed
Generation stopped with an error. Read data.error_message and stop polling.

Polling and Errors

AuthenticationFor a 401 response, check the Bearer API key in Authorization, update the credentials, and retry.
ValidationFor a 400 response, use the response details to check required fields, parameter ranges, and available credits, then adjust and resubmit.
Network and timeoutIf a status query encounters a network error or timeout, retain the original task_id and retry the query, then handle the result according to the returned task status.
Polling intervalPoll status with a 2-second base interval, and gradually increase the interval for longer tasks.
Terminal statesContinue only for not_started or running. Stop immediately on finished or failed.
Callback optionProvide callback_url at the request top level to receive the final flat task object; polling remains available if delivery fails.

Endpoint limits

Specification	Value	Details
Input mode	First-frame image with optional text prompt	image_urls requires exactly one image; prompt is optional.
Output	Video	Returns an asynchronous task ID.
Duration	3–15 seconds	Integer range, default 5 seconds.
Resolution	1080p	Fixed by the Pro tier; not a request field.
Billing basis	Output seconds × 22 credits/sec	Default 5s is 110 credits ($0.55).

View the Kling 3.0 Turbo Pro Image to Video API docs

Kling 3.0 Turbo Pro Image to Video

Kling 3.0 Turbo Pro Image to Video anchors generation on exactly one first-frame image, with an optional text prompt or 1–6 shot storyboard, to produce 3–15 second studio-grade 1080p video. It fits product animation, talking-head performance, short ad sequences, and concept-to-motion previews while preserving framing and materials with stable motion and native audio-visual sync. With multi_prompt, omitting top-level duration also allows shot totals of 1–2 seconds.

Why Choose This?

Precise first-frame animationUses exactly one public image as the opening frame to animate products, characters, or concept art, with aspect ratio following the source.
Studio-grade 1080p deliveryThe Pro tier locks output at full HD 1080p, with richer texture and edge detail ready for editorial timelines or paid media delivery.
Native audio-visual lip syncGenerates audio with the picture and keeps lip motion, dialogue cues, and on-screen events naturally aligned.
Cinematic camera directionFollows prompt-guided moves such as push-ins, tracking shots, and low-angle passes for intentional spatial staging.
1–6 shot storyboard controlPlan up to six shots with multi_prompt, setting framing, action, and duration while locking character and setting consistency across cuts.
Flexible 3–15 second lengthChoose any integer duration from 3 to 15 seconds, defaulting to 5 seconds for hooks, demos, and short story beats.

Parameters

Parameter	Requirement	Description
image_urls	Required	String array with exactly one public image URL used as the first frame.
prompt	Optional	String, 1–2500 characters. Mutually exclusive with multi_prompt.
duration	Optional	An explicit duration must be 3–15 seconds and equal the shot total when multi_prompt is set. Omit it to use the shot total (1–15 seconds); without multi_prompt it defaults to 5 seconds. Default`Shot total / 5`
multi_prompt	Optional	1–6 shots, each with a nonblank prompt and optional duration of 1–15 seconds (default 5). Total duration must not exceed 15 seconds. Mutually exclusive with a nonblank prompt.
aspect_ratio	Optional	The output aspect ratio follows the input image; aspect_ratio has no effect on this endpoint.

How to Use

Prepare the first-frame imageProvide exactly one publicly reachable image URL as the first frame. Keep the subject clear and the composition stable; aspect ratio follows that image.
Write the motion promptIn prompt, describe subject action, environmental interaction, camera moves, and desired sound cues, or switch to multi_prompt for shot planning.
Plan a multi-shot storyboardFor segmented storytelling, configure 1–6 shots in multi_prompt with per-shot prompts and durations, keeping the total length within 15 seconds.
Set the output durationWithout multi_prompt, duration is an integer from 3 to 15 seconds, defaulting to 5. With multi_prompt, omit top-level duration to use the shot total (1–15 seconds); if supplied, it must be 3–15 seconds and equal that total.
Confirm cost and runReview the run-button estimate billed at 22 credits per output second, then click Run after the image and prompts are ready.
Preview and download the videoWhen the task finishes, preview the 1080p picture and synced audio in the output panel, then download the video file.

Pricing

Billed by output video seconds. 1 credit = $0.005. The Pro tier is fixed at 1080p.

Usage	Rate	Details
1080p	22 credits/sec ($0.11/sec)	Default 5s at 1080p is 110 credits ($0.55). Official comparison $0.1375/sec.

Best Use Cases

E-commerce product animationTurn still product frames into motion clips with camera moves and material reflections that highlight form and finish.
Talking-head and character performanceAnimate portrait or character stills into speech, expression, and gesture takes with native lip sync for dialogue beats.
Multi-shot short ad storytellingGenerate a full ad cadence in one pass with 1–6 shots while keeping the branded subject and setting consistent.
Concept art motion previewsBring concept frames to life as 1080p previs to validate composition, lighting, and camera language before production.
High-volume social short clipsIterate 3–15 second vertical or landscape variants from the same visual asset for Reels, Shorts, and rapid publishing.

Pro Tips

Start with a sharp first frame with clean edges and minimal occlusion, then restate key appearance cues in the prompt to reinforce identity and materials.
Describe camera amplitude and pacing explicitly, such as a slow body glide followed by a steady pull-back, instead of a vague cinematic move.
For multi-shot runs, define framing, action, and duration per shot, and keep wardrobe and setting keywords consistent across cuts.
Use 5–8 seconds for a single action beat; for a short story arc, split beats with multi_prompt and keep the total within 15 seconds.
When lip sync or ambience matters, add dialogue language, emotion, and soundscape cues so audio events align with the picture.

Usage notes

Kling 3.0 Turbo Pro Image to Video is driven by exactly one first-frame image; prompt and multi_prompt are mutually exclusive.
Output is fixed at 1080p with aspect ratio following the first-frame image; duration is an integer from 3 to 15 seconds, default 5.
Billing is per output second at 22 credits/sec ($0.11/sec), where 1 credit = $0.005; the default 5-second clip costs 110 credits.
After API submission, save the returned task_id to poll progress and retrieve the final video file URL.

Related Models

Kling 3.0 Turbo Standard Text to Video

Kling 3.0 Turbo Standard Image to Video

Kling 3.0 Turbo Pro Text to Video

Kling 3.0

Kling 3.0 Turbo Pro Image to Video API frequently asked questions

What is the Kling 3.0 Turbo Pro Image to Video API?

Kling 3.0 Turbo Pro Image to Video is a Kuaishou (Kling AI) model for generating video from a first-frame image. It turns exactly one still image and an optional prompt into 1080p video with deep detail restoration, native audio-visual lip sync, and cinematic camera direction. Built on Kling 3.0 multi-shot storytelling and physics-aware motion modeling, it preserves the source subject, composition, and material texture while adding coherent motion and shot pacing. You can call it programmatically or try it from the playground above. Without multi_prompt, duration is 3–15 seconds. With multi_prompt, omitting top-level duration also allows a shot total of 1 or 2 seconds.

How many single reference images does Kling 3.0 Turbo Pro Image to Video need?

It needs exactly one public image URL as the first frame. That image anchors the opening composition and subject appearance, with aspect ratio following the source; optional prompt or multi_prompt guidance then shapes motion, camera, and sound.

What input material quality tips apply to Kling 3.0 Turbo Pro Image to Video?

Prefer a sharp, evenly lit first frame with clean edges and a clear subject. Restate face, wardrobe, product materials, and key structures in the prompt to extend identity and physical texture; call out environment elements you want to keep.

How do I control camera move amplitude in Kling 3.0 Turbo Pro Image to Video?

Write specific camera direction, path, and speed in the prompt, such as a slow lateral glide followed by a slight tilt up. More concrete amplitude language yields closer staging; in multi-shot mode, assign framing and moves per shot.

How does Kling 3.0 Turbo Pro Image to Video handle long-action story narrative?

multi_prompt accepts 1–6 shots. Each shot needs a nonblank prompt and an optional integer duration of 1–15 seconds, defaulting to 5. The sum must not exceed 15 seconds. Omit top-level duration to use that sum, including totals of 1 or 2 seconds. If supplied, top-level duration must be an integer from 3 to 15 and equal the sum. multi_prompt cannot be combined with a nonblank top-level prompt. Edit storyboards in JSON mode; switching to the form keeps JSON mode and all shot settings. Keep character and setting descriptions consistent across shots.

Does Kling 3.0 Turbo Pro Image to Video allow commercial licensing?

Yes, commercial use is allowed under standard Kling AI licensing and the platform service terms. Before ads, ecommerce assets, or client delivery, confirm the authorization scope for your account plan and generated outputs.

How does Kling 3.0 Turbo Pro Image to Video credit use compare with Standard?

Pro Image to Video is fixed at 1080p and billed at 22 credits per second, while Standard Image to Video in the same family is fixed at 720p and billed at 17 credits per second. For equal duration, Pro costs more credits in exchange for studio-grade full HD; draft on Standard, then switch to Pro for finals.