Kling 3.0 Turbo Standard Text to Video API

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

Kling 3.0 Turbo Standard Text to Video turns text prompts into 3–15 second 720p video with high-throughput generation, native lip-synced multilingual audio, and multi_prompt storyboarding for 1–6 shots. It keeps character appearance and scene continuity across cuts while aligning motion with dialogue and ambient sound. 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 Image to Video Kling 3.0 Turbo Pro Text to Video Kling 3.0 Turbo Pro Image to Video Kling 3.0

Examples

Macro slow-motion shot of a raindrop falling onto a mossy forest floor, ripples expanding in a tiny puddle, spore dust drifting in a shaft of soft light, ultra detailed, nature documentary style

Rainy night in a neon-lit city street, a pedestrian with a transparent umbrella crosses the wet zebra crossing, reflections shimmering on the asphalt, cinematic vertical shot

A chef tossing a wok over intense heat, flames leaping up and wrapping around the ingredients, sparks and smoke, dynamic close-up in a professional kitchen

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-std/text-to-video",
  "input": {
    "prompt": "Macro slow-motion shot of a raindrop falling onto a mossy forest floor, ripples expanding in a tiny puddle, spore dust drifting in a shaft of soft light, ultra detailed, nature documentary style",
    "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-std/text-to-video",
  "input": {
    "prompt": "Macro slow-motion shot of a raindrop falling onto a mossy forest floor, ripples expanding in a tiny puddle, spore dust drifting in a shaft of soft light, ultra detailed, nature documentary style",
    "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	720p	Fixed by the Standard tier; not a request field.
Aspect ratio	16:9 / 9:16 / 1:1	Default is 16:9.
Billing basis	Output seconds × 17 credits/sec	Default 5s is 85 credits ($0.425).

View the Kling 3.0 Turbo Standard Text to Video API docs

Kling 3.0 Turbo Standard Text to Video

Kling 3.0 Turbo Standard Text to Video is Kuaishou Kling AI’s high-throughput model for agile video creation from text. From natural-language prompts alone, it outputs 3–15 second 720p clips with multilingual lip-synced dialogue and ambient audio. With native multi_prompt storyboarding, a single request can sequence up to 6 coherent shots—ideal for social short-form batches, rapid concept drafts, and digital marketing content. With multi_prompt, omitting top-level duration also allows shot totals of 1–2 seconds.

Why Choose This?

High-throughput, low-latency iterationTuned for volume production so you can validate many prompt variants quickly with shorter wait times per task.
Native audio with faithful lip syncSynthesizes matching audio with the picture, aligning dialogue lip sync and natural speech so you skip separate dubbing and A/V alignment.
Multi-shot storyboarding up to 6 shotsUse multi_prompt to define 1–6 shots with per-shot prompts and durations; the model schedules pacing and cuts in one run.
Strong subject continuity across cutsMaintains face, wardrobe, and setting consistency as framing and camera moves change between shots.
Flexible 3–15 second integer durationPick any integer length from 3 to 15 seconds—tight 3-second hooks or fuller short narratives—with a default of 5 seconds.
Cost-efficient fixed 720p Standard rateDelivers clear 720p at 17 credits per second ($0.085/sec), lowering the cost of large-scale content production.

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, describe subject action, camera, lighting, and dialogue or ambience cues. For a single narrative block, use prompt only—do not submit it together with multi_prompt.
Configure multi_prompt storyboardingFor multi-shot runs, switch to multi_prompt and add 1–6 shot objects, each with its own prompt and optional duration.
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.
Select aspect ratioPick 16:9, 9:16, or 1:1 to match distribution layout; the Playground preselects 16:9.
Verify total shot lengthUse 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.
Review the cost and runCheck the cost shown on the Run button, finish the prompt and 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 Standard tier is fixed at 720p.

Usage	Rate	Details
720p	17 credits/sec ($0.085/sec)	Default 5s at 720p is 85 credits ($0.425). Official comparison $0.106/sec.

Best Use Cases

High-volume social short-formBatch 9:16 clips at short durations for TikTok, Reels, and Shorts workflows that need fast turnaround.
Multi-shot ad sequences in one runStoryboard openers, tracking beats, and closers with multi_prompt while keeping product and talent consistent across cuts.
Rapid concept prototypingIterate prompts and pacing at 720p Standard before promoting selected ideas to higher-resolution delivery tiers.
Lip-synced talking performancesDirect talking-heads, dialogue, or reaction shots with speech cues so mouth motion tracks multilingual delivery.
E-commerce and brand promosDescribe product benefits and scene motion in text to produce marketing clips with ambient sound for horizontal or vertical placement.

Pro Tips

Specify framing, camera move, and lighting—e.g., “low-angle tracking shot with side light”—so motion and space land clearly.
With multi_prompt, reuse the same character appearance and wardrobe wording across shots to lock continuity.
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.
For vertical social, choose 9:16 and state where the subject sits in the tall frame.
When you need lip sync, add language and tone cues in the prompt to guide native audiovisual alignment.

Usage notes

Kling 3.0 Turbo Standard Text to Video is driven by prompt or multi_prompt (mutually exclusive), with configurable duration and aspect_ratio.
The Standard tier is fixed at 720p and includes native audio with lip sync in the result—no separate sound toggle field.
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

Gemini Omni 1.1 Flash Text-to-Video preview

Gemini Omni 1.1 Flash Text-to-VideoGoogle Gemini Omni 1.1 Flash video model with native audio, text-to-video, first/last-frame image-to-video, reference-image video, and 3–10 second video edit at 360p to 4K.

Gemini Omni 1.1 Flash Image-to-Video preview

Gemini Omni 1.1 Flash Image-to-VideoGoogle Gemini Omni 1.1 Flash video model with native audio, text-to-video, first/last-frame image-to-video, reference-image video, and 3–10 second video edit at 360p to 4K.

Gemini Omni 1.1 Flash Reference-to-Video preview

Gemini Omni 1.1 Flash Reference-to-VideoGoogle Gemini Omni 1.1 Flash video model with native audio, text-to-video, first/last-frame image-to-video, reference-image video, and 3–10 second video edit at 360p to 4K.

Gemini Omni 1.1 Flash Video Edit preview

Gemini Omni 1.1 Flash Video EditGoogle Gemini Omni 1.1 Flash video model with native audio, text-to-video, first/last-frame image-to-video, reference-image video, and 3–10 second video edit at 360p to 4K.

Wan 3.0 Text-to-VideoAlibaba Tongyi Lab's Wan 3.0 multimodal video model with separate text-to-video, first/last-frame image-to-video, and reference-to-video workflows at 480p, 720p, or 1080p for 2 to 30 seconds.

Wan 3.0 Image-to-VideoAlibaba Tongyi Lab's Wan 3.0 multimodal video model with separate text-to-video, first/last-frame image-to-video, and reference-to-video workflows at 480p, 720p, or 1080p for 2 to 30 seconds.

Wan 3.0 Reference-to-VideoAlibaba Tongyi Lab's Wan 3.0 multimodal video model with separate text-to-video, first/last-frame image-to-video, and reference-to-video workflows at 480p, 720p, or 1080p for 2 to 30 seconds.

Wan 3.0 Prime Text-to-VideoAlibaba Wan 3.0 Prime video model with text-to-video, image-to-video, and reference-to-video workflows at 480p, 720p, or 1080p for 2 to 30 seconds with optional synchronized audio.

Wan 3.0 Prime Image-to-VideoAlibaba Wan 3.0 Prime video model with text-to-video, image-to-video, and reference-to-video workflows at 480p, 720p, or 1080p for 2 to 30 seconds with optional synchronized audio.

Wan 3.0 Prime Reference-to-Video preview

Wan 3.0 Prime Reference-to-VideoAlibaba Wan 3.0 Prime video model with text-to-video, image-to-video, and reference-to-video workflows at 480p, 720p, or 1080p for 2 to 30 seconds with optional synchronized audio.

FLUX 3 Text to VideoBlack Forest Labs FLUX 3 video model with text-to-video, image-to-video, first-last-frame, extend-video, and keyframes workflows at 720p or 1080p for 5 to 20 seconds, with optional native audio.

FLUX 3 Image to VideoBlack Forest Labs FLUX 3 video model with text-to-video, image-to-video, first-last-frame, extend-video, and keyframes workflows at 720p or 1080p for 5 to 20 seconds, with optional native audio.

FLUX 3 First Last Frame to Video preview

FLUX 3 First Last Frame to VideoBlack Forest Labs FLUX 3 video model with text-to-video, image-to-video, first-last-frame, extend-video, and keyframes workflows at 720p or 1080p for 5 to 20 seconds, with optional native audio.

FLUX 3 Extend VideoBlack Forest Labs FLUX 3 video model with text-to-video, image-to-video, first-last-frame, extend-video, and keyframes workflows at 720p or 1080p for 5 to 20 seconds, with optional native audio.

FLUX 3 Keyframes to VideoBlack Forest Labs FLUX 3 video model with text-to-video, image-to-video, first-last-frame, extend-video, and keyframes workflows at 720p or 1080p for 5 to 20 seconds, with optional native audio.

Seedance 2.5 Text-to-VideoByteDance Seed's Seedance 2.5 video model with separate text-to-video, start/end-frame image-to-video, and multimodal reference-to-video API workflows at 480p, 720p, or 1080p for 4 to 30 seconds.

Kling 3.0 Turbo Standard Text to Video API frequently asked questions

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

Kling 3.0 Turbo Standard Text to Video is a Kuaishou Kling AI model for generating video from text prompts. It creates 720p clips with high-throughput generation, native lip-synced multilingual audio, and multi_prompt storyboarding for up to 6 shots. Built on the Kling 3.0 Turbo high-speed generation stack, it follows prompt narrative and camera direction while keeping character appearance, scene continuity, and audiovisual alignment across cuts. 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 does Kling 3.0 Turbo Standard Text to Video use multi_prompt?

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.

How long can Kling 3.0 Turbo Standard Text to Video generate?

Without multi_prompt, duration is an integer from 3 to 15 seconds and defaults to 5. With multi_prompt, each shot defaults to 5 seconds and the sum must not exceed 15. Omit top-level duration to use the sum, including totals of 1 or 2 seconds; an explicit top-level duration must be 3–15 and equal that sum.

Does Kling 3.0 Turbo Standard Text to Video generate native audio?

Yes. Native audio is generated with the picture, with lip sync aligned to multilingual speech plus matching ambience and action cues. Add dialogue language, tone, or environmental sound directions in the prompt to guide the soundtrack; there is no separate sound toggle field.

Which aspect ratios does Kling 3.0 Turbo Standard Text to Video support?

It supports 16:9, 9:16, and 1:1, with 16:9 preselected in the Playground. Use 16:9 for landscape storytelling, 9:16 for vertical shorts, and 1:1 for square layouts; full options are listed in the Parameters section.

How does Kling 3.0 Turbo Standard Text to Video differ from Pro?

Standard is fixed at 720p and billed at 17 credits per second—best for high-throughput drafts and batch iteration. The sibling Pro Text to Video tier is fixed at 1080p for sharper finals. Both support native audiovisual sync and multi_prompt storyboarding, with 3–15 second durations or shot totals of 1–2 seconds when top-level duration is omitted; choose by clarity needs versus cost.

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

Billing is by output seconds at 17 credits/sec for 720p ($0.085/sec), where 1 credit = $0.005. A default 5-second run costs 85 credits ($0.425); longer clips cost more—see the Pricing section for the exact rate.