Kling 4.0 Video Edit API

kwaivgi/kling-v4.0/video-edit

720p / 1080p · 3–30 sec

Kling 4.0 Video Edit transforms an existing 3–30 second video from a written instruction, restyling scenes, swapping objects or adding elements at 720p or 1080p. It keeps the original timing, people and camera path that you ask to preserve while applying the change across every frame.

Input

Prompt305/26000

Video Url

Drag and drop files, paste from clipboard, or provide a URL. Required. One MP4, MOV or WebM source video, 3–30 seconds, up to 100 MB.

1/1 files added

Reference Image Urls

Drag and drop files, paste from clipboard, or provide a URL. Up to 10 images, cited in the prompt as @Image1, @Image2…

Duration

Resolution

Switch to JSON to add image-based kling_elements.

OutputExample

Continue with

Kling 4.0 Text to Video Kling 4.0 Image to Video Kling 4.0 Reference to Video Kling 3.0 Turbo Pro Text to Video

REST API

Quick Start

Make your first Kling 4.0 Video Edit request in three steps. The example turns an afternoon street into a snowy evening at the source length and returns a task_id.

Connect to the Vidgo API

Create an API key, keep it on your server, and send it in the Authorization header as a Bearer token.

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

Submit one generation task

Run the short example with video_url and an edit prompt; omit duration to match the source.

Submit request

curl --request POST \
  --url "https://api.vidgo.ai/api/generate/submit" \
  --header "Authorization: Bearer $VIDGO_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
  "model": "kwaivgi/kling-v4.0/video-edit",
  "input": {
    "prompt": "Turn the afternoon street in this video into a snowy winter evening: settle a thin layer of snow on rooftops, cars and the pavement, add gently falling flakes and warm light in the shop windows. Keep the people, their movement and the camera path exactly as in the source. No text, no logos, no watermark.",
    "resolution": "720p",
    "video_url": "https://cdn.vidgo.ai/apis/models/kwaivgi/kling-v4.0/video-edit/v1/02/input-source.mp4"
  }
}'

Wait for the result

Use the returned task_id to check the same task until it reaches finished or failed. On success, read data.files[].file_url.

Track status

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

Poll every few seconds while the status is not_started or running, and stop on finished or failed. On success, read data.files[].file_url. For longer clips, lengthen the interval gradually or add callback_url to the submit request.

not_startedrunningfinishedfailed

Submit response

{
  "code": 200,
  "data": {
    "task_id": "HSB8M64LBPQ54HHW",
    "status": "not_started",
    "created_time": "2026-11-05T07:05:29"
  }
}

Finished response

{
  "code": 200,
  "data": {
    "task_id": "HSB8M64LBPQ54HHW",
    "status": "finished",
    "files": [
      {
        "file_url": "https://cdn.vidgo.ai/apis/models/kwaivgi/kling-v4.0/video-edit/v2/01/output-01.mp4",
        "file_type": "video"
      }
    ],
    "created_time": "2026-11-05T07:05:29",
    "error_message": null,
    "progress": 100
  }
}

Complete runnable example

Open this after the three-step flow is clear. It combines submission, polling, terminal-state handling and result extraction in one script.

Complete runnable example

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

REQUEST_BODY=$(cat <<'JSON'
{
  "model": "kwaivgi/kling-v4.0/video-edit",
  "input": {
    "prompt": "Turn the afternoon street in this video into a snowy winter evening: settle a thin layer of snow on rooftops, cars and the pavement, add gently falling flakes and warm light in the shop windows. Keep the people, their movement and the camera path exactly as in the source. No text, no logos, no watermark.",
    "resolution": "720p",
    "video_url": "https://cdn.vidgo.ai/apis/models/kwaivgi/kling-v4.0/video-edit/v1/02/input-source.mp4"
  }
}
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')
if [ -z "$TASK_ID" ]; then
  printf 'Submit response did not include task_id:
%s
' "$SUBMIT_RESPONSE" >&2
  exit 1
fi

while true; do
  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')

  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 2
      ;;
    *)
      printf 'Unexpected task status: %s
' "$STATUS" >&2
      exit 1
      ;;
  esac
done

Request Parameters

model and callback_url belong at the request root; generation parameters belong inside input.

Field	Type	Required	Default	Description
model	string	Yes	—	Fixed to kwaivgi/kling-v4.0/video-edit.
callback_url	string (URL)	No	—	A public HTTP(S) URL that receives the task result when it finishes.
input	object	Yes	—	Generation parameters: video_url and prompt, plus optional duration, resolution, reference_image_urls and image-based kling_elements.
input.prompt	string	Yes	—	Edit instruction, 1–26,000 characters.
input.video_url	string	Yes	—	Source video URL, 3–30 s, ≤100 MB; measured server-side.
input.reference_image_urls	string[]	No	—	≤10 image URLs.
input.kling_elements	object[]	No	—	Image elements: element_input_urls (2–4).
input.duration	integer	No	source length	3–30 s; omitted = source length.
input.resolution	string	No	720p	720p or 1080p.

Response Fields

Submission returns the task identity immediately. Status responses add progress, output files or a failure message as the task advances.

Field	Type	Description
code	integer	Application result code. Successful responses use 0 or 200.
message	string	Human-readable response or error message when present.
data.task_id	string	Task identifier used in the status endpoint path.
data.status	string	Current state: not_started, running, finished or failed.
data.created_time	string	Task creation time in date-time format.
data.progress	number	Completion percentage when the provider reports progress.
data.files[]	array	Generated output files returned after a successful task.
data.files[].file_url	string	Public URL of the generated video.
data.files[].file_type	string	Generated file type, such as video.
data.files[].watermark_url	string \| null	Watermarked output URL when one is available.
data.error_message	string \| null	Failure detail when status is failed.

Task Lifecycle

Treat not_started and running as non-terminal states. finished and failed are terminal; stop polling when either is returned.

not_started
The task has been accepted and is queued to start.
running
The video is being generated. Keep polling the status endpoint.
finished
The task is complete. Read the video URL from data.files[].file_url.
failed
Generation failed. Read data.error_message for details and stop polling.

Polling and Errors

Authentication401 means the Bearer API key is missing or invalid. Check your key in the dashboard before retrying.
Validation400 means a request field is invalid or belongs to another endpoint. Check video_url length (3–30 s) and that kling_elements are image-based.
Polling intervalPoll every few seconds while the task runs, and lengthen the interval gradually for longer clips.
Terminal statesPoll only while the status is not_started or running. Stop on finished or failed.
Callback optionAdd callback_url at the request root to receive the final result without continuous polling.

Model Specifications

Specification	Value	Description
Model	kwaivgi/kling-v4.0/video-edit	Model identifier for text-guided editing of an existing video.
Duration	3–30	Whole seconds; defaults to the source length.
Resolution	720p \| 1080p	Defaults to 720p.
Pricing	17 / 25.5 credits/s	720p / 1080p per billed second; billed seconds = output + max(output, source length).

View the Kling 4.0 Video Edit API documentation

Kling 4.0 Video Edit

Kling 4.0, released by Kuaishou's Kling AI in October 2026, can edit footage as well as generate it. Video Edit takes a source clip of 3–30 seconds and a prompt describing the change, with optional reference images and image elements showing a new look, product or character. Leave duration out to match the source length, and the result returns with a stereo track.

Why choose the Kling 4.0 Video Edit API?

Edit with plain instructionsDescribe the change, such as turning day to night or replacing a jacket, and what must stay the same.
Show the target with referencesAdd up to 10 reference images or image elements to define a new product, outfit or style.
Keeps the source timingOmit duration and the edit matches the source length, ready to drop back into a timeline.
Predictable billingA published formula based on output and source length lets you price an edit before submitting.

Parameters

Parameter	Requirement	Description
prompt	Required	The edit instruction: what to change in the source video and what to keep. 1–26,000 characters after trimming. Default`—`
video_url	Required	Public HTTP(S) URL of the source video, 3–30 seconds and up to 100 MB. Its length is measured on the server and used for billing. Default`—`
reference_image_urls	Optional	Up to 10 image URLs that show the look, object or style the edit should introduce, cited as @Image1 and so on. Default`—`
kling_elements	Optional	Image-based subjects to place in the edit: each element has element_input_urls with 2–4 images of the same subject. Default`—`
duration	Optional	Output length in seconds, 3–30. Leave it out to match the source video; billing then uses the source length rounded up. Default`source length`
resolution	Optional	720p or 1080p. The resolution sets the per-second rate. Default`720p`

How to Use

Upload the source videoUse a 3–30 second clip up to 100 MB as video_url.
Write the edit instructionState what to change and what to keep, and cite any references as @Image1, @Element1.
Choose length and resolutionKeep the source length or set 3–30 seconds, then pick 720p or 1080p.
Submit and collect the videoSend the request, then poll with the task_id or wait for callback_url.

Usage and billing

Kling 4.0 Video Edit uses the input-video rate on billed seconds: output seconds plus the longer of output seconds or source length, rounded up. In plain words, you pay a lower per-second rate on at least twice the output length. Example: editing a 10-second source and keeping its length at 720p bills 20 seconds, 340 credits ($1.70); at 1080p, 510 credits ($2.55).

Usage	Rate	Details
720p with input video	17 credits / billed second	$0.085 / billed second. Billed seconds = output seconds + the longer of output seconds or input video length (rounded up).
1080p with input video	25.5 credits / billed second	$0.1275 / billed second, same billed-seconds rule as 720p.

Best Use Cases

Restyling footageChange season, time of day or visual style while keeping the action.
Product and wardrobe swapsReplace an object or outfit using reference images of the new item.
Background replacementMove a scene to a new location described in the prompt.
Localized ad variantsProduce versions of one shoot for different markets or seasons.

Pro Tips

Name what must stay unchanged, such as people, timing and camera path, as clearly as the change itself.
Use reference images for anything that must look exact, such as a product or packaging design.
Trim the source to the part you need: billing counts the source length.
Leave duration out to keep the edit in sync with the original edit timeline.

Notes

video_url and prompt are required; reference_image_urls (≤10) and image-based kling_elements are optional.
The source runs 3–30 seconds and up to 100 MB; the server measures its length for billing.
Without duration, the output matches the source and is billed as twice the source length rounded up.
Credits are reserved at submission using the measured source length.

Related Models

PixVerse V6 Max Text to VideoPixVerse V6 Max Text to Video turns a prompt into 1–15 second videos at 360p to 1080p, with eight aspect ratios and an optional native audio track for dialogue, effects and music. Describe subjects, actions and sound in one prompt, then pick the length and format for each placement.

PixVerse V6 Max Image to VideoPixVerse V6 Max Image to Video animates one JPEG, PNG or WebP image into a 1–15 second video at 360p to 1080p, with an optional native audio track. The image sets the subject and framing, and a prompt of up to 2,048 characters directs motion, camera and sound.

OmniHuman 2.0 Audio to VideoOmniHuman 2.0 Audio to Video turns one character image and 4–300 seconds of speech or music into a 720p video, with lips, expression and gestures following the audio. The image keeps the character's look and framing, while an optional prompt adds camera moves and actions.

FLUX 3 Max Text to VideoFLUX 3 Max Text to Video turns a written shot into a 5–20 second 720p or 1080p video with native audio and eight aspect ratios. It follows the camera moves, lighting and sound cues you describe, so one prompt returns picture and audio together.

FLUX 3 Max Image to VideoFLUX 3 Max Image to Video animates a start image into a 5–20 second 720p or 1080p clip with native audio, optionally landing on an end frame you supply. It keeps the composition, subject and palette of your images while adding the motion and sound in the prompt.

FLUX 3 Max Keyframes to VideoFLUX 3 Max Keyframes to Video turns 1–10 images pinned to exact frames into a single 5–20 second 720p or 1080p clip with native audio. Each image appears at the frame_index you set on a 24 fps timeline, so the story beats land where you planned them.

Kling 4.0 Text to VideoKling 4.0 Text to Video turns a prompt or multi-shot script into one 3–30 second 720p or 1080p video with stereo audio and five aspect ratios. It keeps scenes coherent across long takes and shot changes while following your camera, dialogue and sound directions.

Kling 4.0 Image to VideoKling 4.0 Image to Video animates a start image into a 3–30 second 720p or 1080p video with stereo audio, optionally finishing on an end frame you choose. It keeps the subject, framing and look of your image while adding the motion, camera work and sound in your prompt.

Kling 4.0 Reference to VideoKling 4.0 Reference to Video turns reference images, videos and reusable elements into a 3–30 second 720p or 1080p video with stereo audio, cited as @Image1, @Video1 or @Element1. It keeps characters, products and settings consistent with your references inside the new scene you describe.

Vidu Q4 Image to VideoVidu Q4 Image to Video turns one start image and an optional motion prompt into a 3–16 second clip at 540p up to 4K. Your image sets the opening frame, so subject, setting and aspect ratio carry through while the prompt directs movement and camera.

Vidu Q4 Reference to VideoVidu Q4 Reference to Video combines a prompt with up to 12 reference images and 3 voice clips into 3–16 second videos at up to 4K. Tag each reference in the prompt to keep characters, products and places recognisable, with optional generated audio at no extra cost.

Gemini Omni 1.1 Flash Text-to-Video preview

Gemini Omni 1.1 Flash Text-to-VideoGemini Omni 1.1 Flash Text-to-Video. Create 4–10 second videos with native audio from text, directing camera, lighting, and sound.

Gemini Omni 1.1 Flash Image-to-Video preview

Gemini Omni 1.1 Flash Image-to-VideoGemini Omni 1.1 Flash Image-to-Video. Animate a start image with native audio and add an optional end frame to guide the closing shot.

Gemini Omni 1.1 Flash Reference-to-Video preview

Gemini Omni 1.1 Flash Reference-to-VideoGemini Omni 1.1 Flash Reference-to-Video. Use 1–7 images to guide characters, products, and style in new video scenes with sound.

Gemini Omni 1.1 Flash Video Edit preview

Gemini Omni 1.1 Flash Video EditGemini Omni 1.1 Flash Video Edit. Edit 3–10 second videos through natural language with up to 5 reference images for visual guidance.

MiniMax H3 Max Turbo Text to Video preview

MiniMax H3 Max Turbo Text to VideoMiniMax H3 Max Turbo Text to Video turns text into coherent 5–15 second videos with synchronized native stereo audio and fast generation. It follows physical motion while rendering subtle changes in light and shadow.

Kling 4.0 Video Edit API FAQ

What is the Kling 4.0 Video Edit API?

Kling 4.0 Video Edit is a Kuaishou model for editing existing video with text instructions, released by Kling AI in October 2026. It takes a 3–30 second source clip and a prompt, plus optional reference images and image elements, and returns the edited video at 720p or 1080p with a stereo track. The model applies the requested change across the clip while keeping the motion, timing and camera path you ask it to preserve. You can call it programmatically or try it from the playground above.

How is Kling 4.0 Video Edit billed?

You pay 17 credits per billed second at 720p or 25.5 at 1080p. Billed seconds are the output length plus the longer of the output length or the source length, rounded up, so a 10-second edit of a 10-second source bills 20 seconds: 340 credits ($1.70) at 720p.

What happens to Kling 4.0 Video Edit pricing if I leave duration out?

The output matches the source, and the output length used for billing is the source length rounded up. A 7.4-second source therefore bills 8 + 8 = 16 seconds, 272 credits at 720p.

How long can the Kling 4.0 Video Edit source video be?

The source must run 3–30 seconds and be at most 100 MB. The server downloads and measures it before the task starts.

Can Kling 4.0 Video Edit use reference images?

Yes. Add up to 10 reference_image_urls, or image-based kling_elements with 2–4 images of one subject, and cite them in the prompt as @Image1 or @Element1 to show exactly what should appear.

How do I keep people and motion unchanged in Kling 4.0 Video Edit?

State it in the prompt alongside the change, for example "keep the people, their movement and the camera path exactly as in the source", and limit the instruction to the elements you want to alter.

Which resolutions does Kling 4.0 Video Edit output?

Choose 720p, the default, or 1080p. The output keeps the source framing, and the resolution selects the per-second rate.