Kling 3.0 Turbo Pro Text to Video API

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

Kling 3.0 Turbo Pro Text to Video turns text prompts into 3–15 second flagship 1080p video with refined textures and physics dynamics, native audio-visual lip sync, and multi-shot scripts of up to 6 shots. It keeps character appearance and scene continuity across cuts while aligning dialogue lip sync and ambient sound with on-screen action. With multi_prompt, omitting top-level duration also allows shot totals of 1–2 seconds.

Input

Prompt

0/2500

Duration

Aspect ratio

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 Image to Video Kling 3.0

Examples

Low drone shot skimming over golden sunset waves crashing against dark coastal rocks, spray catching the warm light, cinematic color grading, epic seascape

A great grey owl in a snowy forest turning its head to look directly at the camera, snowflakes drifting down, soft winter light, wildlife documentary close-up

A green sea turtle gliding over a vibrant coral reef, sun rays piercing through crystal clear blue water, schools of small fish scattering, underwater documentary footage

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/text-to-video",
  "input": {
    "prompt": "Low drone shot skimming over golden sunset waves crashing against dark coastal rocks, spray catching the warm light, cinematic color grading, epic seascape",
    "duration": 5,
    "aspect_ratio": "16:9"
  }
}
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/text-to-video",
  "input": {
    "prompt": "Low drone shot skimming over golden sunset waves crashing against dark coastal rocks, spray catching the warm light, cinematic color grading, epic seascape",
    "duration": 5,
    "aspect_ratio": "16:9"
  }
}
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
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.
aspect_ratio	string	No	16:9	Framing: 16:9, 9:16, or 1:1.
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.

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	Text prompt	Natural language instructions for scene and motion.
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.
Aspect ratio	16:9 / 9:16 / 1:1	Default is 16:9.
Billing basis	Output seconds × 22 credits/sec	Default 5s is 110 credits ($0.55).

View the Kling 3.0 Turbo Pro Text to Video API docs

Kling 3.0 Turbo Pro Text to Video

Kling 3.0 Turbo Pro Text to Video is built for delivery-ready shorts: from natural-language prompts alone it produces 3–15 second flagship 1080p motion with synchronized multilingual dialogue lip sync and ambient sound. With finer texture rendering and physics dynamics, plus multi_prompt storyboards of up to 6 shots, it fits brand ads, vertical social narratives, and performance clips that need tight mouth alignment. With multi_prompt, omitting top-level duration also allows shot totals of 1–2 seconds.

Why Choose This?

Flagship 1080p delivery qualityThe Pro tier locks studio-grade full HD 1080p with clearer edges and material detail, ready for editorial finishing and final delivery.
Refined textures and physics dynamicsStrengthens cloth, rigid-body, and environmental interaction so subject motion and lighting stay natural as the camera advances.
Native audio-visual lip syncSynthesizes matching audio with the picture and aligns dialogue mouth shapes to speech—ideal for talking-heads, dialogue, and reaction shots.
Multi-shot scripts up to 6 shotsUse multi_prompt to define prompts and durations for 1–6 shots in one request; the model sequences cuts along the timeline.
Cross-shot subject and scene continuityKeeps faces, wardrobe, and setting cues consistent through framing changes and camera moves for complete short-form arcs.
Flexible 3–15s duration and framingInteger durations default to 5 seconds, with 16:9, 9:16, and 1:1 aspect ratios for landscape finals and vertical social placements.

Parameters

Parameter	Requirement	Description
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`
aspect_ratio	Optional	String. Text-to-video framing; the Playground preselects 16:9. Default`16:99:161:1`
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.

How to Use

Write the scene promptIn prompt, specify subject look, action, camera moves, and the sound cues you want. For multi-shot work, switch to multi_prompt and describe each shot separately.
Set 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.
Choose aspect ratioPick 16:9, 9:16, or 1:1 for your delivery layout; the Playground defaults to 16:9. For vertical social content, select 9:16 directly.
Confirm 1080p deliveryThe Pro tier always outputs 1080p—no separate resolution field is required—so results are ready for finals and HD review.
Storyboard multi-shot (optional)For multi-shot narratives, enable multi_prompt with 1–6 shots, keep it mutually exclusive with prompt, and keep total duration at or under 15 seconds.
Review the cost and runCheck the cost shown on the Run button (output seconds × 22 credits/sec), finish your settings, then click Run.
Preview and download the videoWhen the task finishes, preview picture and synchronized audio in the output panel, then select Download video to save the result.

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

Brand ads and product finalsDescribe product look, camera path, and pacing in detail to generate 1080p promo clips ready for editorial.
Multi-shot advertising scriptsUse multi_prompt to stage close-ups, tracking beats, and closing frames in one complete ad arc.
Vertical social storytellingChoose 9:16 with plot and sound cues to produce high-definition vertical clips with lip-synced dialogue.
Talking-head and performance shotsLean on native audio-visual lip sync for natural talking-heads, dialogue, and reaction performances.
E-commerce product motionWrite material reflections, hand interaction, and environmental motion to create credible product dynamics.

Pro Tips

Reuse the same appearance and wardrobe wording for a character across multi-shot scripts to stabilize identity between cuts.
State framing, camera move, and action beat per shot—for example, “3s extreme close-up of the sole landing,” then “low-angle side follow as the runner accelerates.”
For lip sync, name the spoken language, emotion, and speech rhythm in the prompt so audio and mouth shapes stay aligned.
Pick 9:16 for vertical feeds; prefer 16:9 for landscape ads and widescreen storytelling.
Use multi_prompt for 1–6 shots, each with a required prompt and optional duration defaulting to 5 seconds. The total must not exceed 15 seconds. Top-level duration can be omitted; if supplied, it must equal the total and be 3–15 seconds.

Usage notes

Kling 3.0 Turbo Pro Text to Video is driven by a text prompt with optional duration and aspect_ratio; use multi_prompt for storyboards—the two inputs are mutually exclusive.
The Pro tier is fixed at 1080p and billed at 22 credits per output second; the default 5-second clip costs 110 credits ($0.55).
After an API submission, save the returned task_id to query progress and retrieve the final media URL.
Generated clips are delivered as standard video files ready for playback and editing software.

Related Models

Kling 3.0 Turbo Standard Text to Video

Kling 3.0 Turbo Standard Image to Video

Kling 3.0 Turbo Pro Image to Video

Kling 3.0

Kling 3.0 Turbo Pro Text to Video API frequently asked questions

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

Kling 3.0 Turbo Pro Text to Video is a Kuaishou (Kling AI) flagship Turbo Pro model for generating video from text prompts. It creates flagship 1080p clips with refined textures and physics dynamics, native audio-visual lip sync, and multi_prompt storyboards of up to 6 shots. Built on the Kling 3.0 family's multi-shot storytelling and joint audiovisual generation, it follows camera and sound design in the prompt while keeping character appearance, scene continuity, and dialogue lip sync aligned. 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.

Is Kling 3.0 Turbo Pro Text to Video 1080p quality delivery-ready?

Yes. The Pro tier always outputs studio-grade full HD 1080p with finer texture and edge detail, so clips can move straight into editorial as final assets. Resolution is fixed by the tier—no separate resolution field is required. Full specs are listed in the Parameters and Endpoint limits sections on this page.

How does Kling 3.0 Turbo Pro Text to Video use multi_prompt storyboards?

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.

Does Kling 3.0 Turbo Pro Text to Video support native lip sync?

Yes. Results include synchronized audio with the picture and mouth-shape alignment for multilingual dialogue—well suited to talking-heads, conversation, and reaction shots. Name the spoken language, emotion, and speech rhythm in the prompt to further guide the soundtrack and lip performance.

Which aspect ratio fits Kling 3.0 Turbo Pro Text to Video?

Choose among 16:9, 9:16, and 1:1; the Playground defaults to 16:9. Prefer 16:9 for landscape ads and finals, select 9:16 for TikTok / Reels / Shorts, and use 1:1 for square covers or social posts. Full options are listed in the Parameters section on this page.

When should I pick Kling 3.0 Turbo Pro Text to Video over the Base model?

Choose this Pro text-to-video tier when you need flagship 1080p delivery, finer textures, and lip-synced shorts. For faster drafts, higher throughput, and a lower per-second cost, switch to the same-family Standard 720p text-to-video tier. Full Kling 3.0 Base emphasizes higher-fidelity cinematic hero shots—compare family options under Related Models on this page.

How is Kling 3.0 Turbo Pro Text to Video billed per second?

Billing is by output video seconds at 22 credits/sec ($0.11/sec, 1 credit = $0.005). The default 5-second clip costs 110 credits ($0.55); longer durations cost more. See the Pricing section on this page for the full rate.