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
Kling 3.0 Turbo Standard Text to Video API
kwaivgi/kling-v3-turbo-std/text-to-videoKling 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.
Your generated video will appear here
Add your prompt and required media, review the settings, then click Run.
Examples
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
- POST
https://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.
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{
"code": 200,
"data": {
"task_id": "task-unified-...",
"status": "running",
"created_time": "2026-09-16T10:00:00Z"
}
}{
"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.
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
doneInput 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_startedThe task was accepted and is waiting to begin.
runningGeneration is in progress. Continue polling the same task_id.
finishedGeneration succeeded. Read every video URL from data.files[].file_url.
failedGeneration 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). |
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.
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.



