Kling 3.0 Turbo for SaaS Onboarding Clips: Nine Tests on a Mock Dashboard, Scored With OCR

A push-in on a mock dashboard at 2.5 seconds. Quillrun, the product on screen, does not exist.

SaaS teams need a steady supply of short clips: a step in the onboarding checklist, a note in the changelog, a post on launch day. Each one usually means someone records a screen, tidies it up and exports it, and then does it all again when the interface changes. A fast video model looks like an obvious shortcut. The question that decides whether it is useful is narrow: can it keep your interface accurate?

A wrong word in a landscape shot is invisible. A wrong label in a product tour is a support ticket. So we tested Kling 3.0 Turbo, Kuaishou’s speed-tuned model (kling-3.0-turbo), on that specific job, and scored the results with OCR as well as by eye.

The scenario is fictional. Quillrun is a small request-tracking product we made up for this test. Its imaginary two-person growth team wants a 5-second clip for each onboarding step, plus short announcements when a feature ships. This week’s feature is a button called Assign all, which hands every unowned request to one person.

We ran nine tests on nine clips, 32 seconds of video in total, for $3.38. That is few clips per condition, usually one, so read the results as what happened on these runs and not as rates. The most useful result surprised us: a two-word prompt, the laziest thing you could write, made the model invent a whole product interaction.

The setup

Kling 3.0 Turbo generates from a text prompt or from one first-frame image. Clips run from 3 to 15 seconds at 720p or 1080p. With a first frame the aspect ratio follows the image, and without one you can choose 16:9, 9:16 or 1:1. Last-frame images are not supported. Jobs are asynchronous: you post, get a task ID and poll.

Here is a condensed version of the request we sent. It is not the exact script, which also handled threads and logging, and the host is a placeholder.

import os, time, requests

BASE = os.environ[“VIDEO_API_BASE”]   # placeholder host

H = {“Authorization”: “Bearer ” + os.environ[“VIDEO_API_KEY”]}

job = {

    “model”: “kling-3.0-turbo”,

    “prompt”: PROMPT,

    “first_frame_image”: SCREENSHOT_URL,   # public URL

    “resolution”: “720p”,

    “duration”: 5,

}

task_id = requests.post(f”{BASE}/v1/videos/generations”, headers=H,

                        json=job, timeout=90).json()[“data”][0][“task_id”]

open(“tasks.log”, “a”).write(task_id + “\n”)   # keep before polling

while True:

    time.sleep(8)

    t = requests.get(f”{BASE}/v1/tasks/{task_id}”, headers=H, timeout=60).json()[“data”]

    if t[“status”] in (“completed”, “failed”, “cancelled”):

        break

print(t[“cost”], t[“result”][“videos”][0][“url”])

Since Quillrun is fictional, it has no real screenshot. We asked an image model for a flat dashboard with exact labels ($0.003) and used that still as the first frame. This is a limitation of the test. A real UI has smaller text and more density than our mock-up, so expect the results below to be, if anything, flattering.

How we scored text. We defined 28 expected labels on that dashboard: 16 unique strings such as “Export March invoices” and “Assign all”, plus repeat counts for items like the four “Waiting” pills. Then we pulled eight evenly spaced frames from each clip and ran them through Apple’s Vision text recognizer. The score is how many of the 28 it read exactly. The source still scored 28. OCR is not a perfect judge, so we looked at every low score by hand.

Test 1: what the prompt has to say

We started with an announcement clip and no screenshot, in the way a busy marketer might write it:

A cool video announcing a new feature for our software app.

And then a version that described the idea as a motion graphic:

Flat 2D motion graphic on a plain dark navy background. Six small white cards sit in a messy pile on the left. They slide one at a time into a neat vertical column on the right, each card landing with a small bounce. Locked-off camera. No people, no text, no logos.

Each was 3 seconds at 720p, took 55 seconds of server time and cost $0.31.

The generic prompt invents a product. The layout prompt stays on brief, apart from the counting.

The generic prompt delivered a polished laptop on a desk showing an analytics dashboard nobody at Quillrun has built, and it ended with a garbled attempt at a headline. Our OCR read nonsense words across that screen. It looks fine for half a second, and it is unusable, because it shows a product that is not yours.

The layout prompt obeyed the important constraints: no people, no text, a fixed camera, and the right colours. It also shows a pattern worth knowing. The column on the right grows to about five cards, yet the pile on the left never shrinks. In our runs the model depicted the scene well and did not conserve objects. For abstract graphics this rarely matters, as nobody counts. It would matter if the clip claimed that assigning six requests leaves zero.

Test 2: pushing in on a screenshot

The camera pushes in very slowly on this software dashboard screenshot. The screen content does not change. All text stays perfectly still and readable. Nothing else moves.

This was 5 seconds at 720p, took 76 seconds and cost $0.51. It is the result that makes the model worth considering for this job.

The zoom is smooth and the words stay words. Status pills and the button eventually leave the frame. OCR scores. Note the red line, covered in Test 3.

OCR scores. Note the red line, covered in Test 3.

OCR scored 27, 28, 28, 28, 26, 27, 23 and 20 across the clip. The late drop is cropping, not corruption: by the end the push-in has moved the status column and the button out of frame, and OCR reports fragments such as “Wai” for words cut by the edge. We inspected the last frame at full size, and every word still visible is correct. The one quality issue is that small white text on the orange pills is the first thing to soften, with OCR misreading single pills in a few frames.

The camera also drifted further left than a centred zoom would. If the feature you are explaining sits at the top right, as Assign all does, this prompt pushes it out of the shot. We did not specify a target. Next time we would say what the camera should move toward, and test whether it complies.

Test 3: the two-word prompt

Next, the same image with a minimal instruction, on the theory that a light touch would leave the interface alone:

Subtle motion.

This was 3 seconds at 720p, took 85 seconds and cost $0.31. It was the most instructive clip of the day.

Nobody asked for a cursor, a cut or a click. The clip contains all three.

A mouse pointer appeared by 1.2 seconds. At 1.71 seconds the clip jumped to a tighter crop. Then the pointer went to the Assign all button, the button faded as though pressed, two status pills turned green and their text dissolved into nonsense. OCR read those two pills as “Astraieg” and “Aauaieg”. The score fell from 27 to 13 at the jump, though much of that fall is because the crop removes the sidebar and clips the left column.

In other words, the model looked at a screenshot with a large orange button, inferred what this kind of video usually shows, and made it up. As a demonstration of its visual inference, this is impressive. For onboarding, it is dangerous, since it depicts a state your product might never show. We saw something similar on the second run with this prompt at 1080p (Test 8), which also gained a cut at 1.79 seconds and a stray floating pill.

The practical rule: on interface footage, a short prompt is not a safe default. State that nothing changes.

Test 4: asking for the click on purpose

If it can invent an interaction, can it perform one on request?

A mouse pointer enters from the bottom of the screen, moves to the orange Assign all button at the top right and clicks it. Then every row that says Unassigned changes to say Priya N. The rest of the interface does not change. Locked-off camera.

This was 4 seconds at 720p, took 115 seconds and cost $0.41.

The path is right. The pointer is a diamond, and the table never updates.

The pointer does enter from the bottom and travels to the button, which is more direction than we expected. But it is a diamond rather than an arrow, it sits on the button without an obvious press, and the table does not change. At the last sampled frame OCR still counted four “Unassigned” and one “Priya N.” The interface text held up well, scoring 26 or 27 in every frame, largely because nothing else happened.

So the model drew a plausible click when we asked for nothing, and missed the click when we specified one. That is one run each, so we would not build a theory on it. Either way, you cannot direct product behaviour this way. If a clip must show what really happens after the click, record the real product.

Test 5: a title card with exact words

Clean product announcement title card. Dark navy background. Large white sans-serif headline in the center reads exactly: Bulk assign is here. Below it, smaller text reads exactly: Now in every Quillrun plan. The text fades in gently and then holds still. Locked-off camera.

This was 3 seconds at 720p, took 44 seconds and cost $0.31, the fastest job of the set.

The fade and the layout are good. The words are not.

The headline reads “Bulk asrin is here”, and the product name became “Quilllrun”. Both errors are stable: they sit there at 1, 2 and 2.9 seconds, so nothing about the motion gives them away. The typography looks entirely convincing, which is the risk. A tired reviewer could pass this.

There is no reason to accept that trade. Text from a local HTML file, rendered with headless Chrome and composited with ffmpeg, took us a few minutes and cost nothing, and it is correct by construction. Generate backgrounds if they help, and set the words yourself. It also makes the clip easy to translate, which matters for a SaaS product with customers in several languages.

Test 6: a multi-shot prompt

Turbo accepts a storyboard written in the prompt, in the form Shot 1,2,…;Shot 2,3,…;, which we read as shot number and length in seconds. The parameters and per-second rates are listed on the Kling 3.0 Turbo API page. A storyboard suits a problem-then-relief announcement:

Shot 1,2,close-up of a person at a desk frowning at a long list on a laptop screen, screen not readable, warm office light;Shot 2,3,wide shot of the same person leaning back and smiling while a colleague gives a thumbs up, same office;

This was 5 seconds at 720p, took 54 seconds and cost $0.51. ffmpeg’s scene filter found exactly one cut, at 2.54 seconds, about half a second later than the 2 seconds we wrote. The character carried over well: same hair, glasses and white blouse in both shots, and a credible office. The colleague was less successful: only a torso at the frame’s edge, with a hand that rises near the end, and we would not call it a clear thumbs up. Treat shot durations as approximate, and put anything you need to land on time in your own edit.

Test 7: vertical for social

We reused the card idea at 9:16 for a launch-day post, with the layout adjusted to top and bottom. This was 3 seconds at 720p, took 54 seconds and cost $0.31. The file came back at a true 720 by 1280, and the camera stayed fixed. The count did not hold: six cards turned into a column of about 12. Combined with Test 1, that makes two out of two runs that failed to conserve the cards. If quantity carries your message, do not trust the model with it. Keep it to a counter you render yourself.

Test 8: does 1080p help the interface text?

We repeated the “Subtle motion.” request from Test 3 at 1080p, 3 seconds. It cost $0.39, against $0.31 at 720p. The first five frames scored 28, 28, 27, 27 and 28, slightly better than the 27, 27, 26, 27 and 27 from the 720p clip, and enlarged crops look a little cleaner. The file was 4.21 MB, 10.9 Mbps, at 1916 by 1080, so note those two pixels if your template expects exactly 1920.

The gain does not rescue the clip. A cut at 1.79 seconds and a stray floating “Waiting” pill wrecked this one too, and the score fell to 18. A sharper version of an invented interaction is still an invented interaction.

The bigger difference was time. This job took 987 seconds of server time, while every other clip took 44 to 115. It is one job, so we can’t tell whether that reflects 1080p or a bad moment in the queue. Allow for slow outliers if you put generation inside a release pipeline, and set your timeouts accordingly. We would draft and usually finish at 720p, where the listed rate is about 20% lower.

Test 9: what an in-app embed weighs, and the free alternative

No new generation here. Onboarding clips load inside a product, often on first run, so size matters. The Test 2 clip downloads at 4.68 MB for 5 seconds, or about 7.4 Mbps, far more than a flat interface needs. It also carries an audio track, which we did not request. All of our Turbo clips did, at levels ranging from -13.0 to -48.3 LUFS, with left and right identical. For a muted in-app loop, strip it with -an.

Re-encoding removes most of the bytes without changing what OCR can read.

ffmpeg -i clip.mp4 -an -c:v libx264 -crf 28 -preset slow \

  -pix_fmt yuv420p -movflags +faststart clip-embed.mp4

OCR barely moved even at CRF 32, while the size fell by about 95%. We would ship CRF 28 and look at it once.

We then did the comparison that should come before any of this. A plain push-in on a real still does not need a model. ffmpeg’s zoompan filter made the same 5-second move on the same image in a moment, at no cost. It came to 626 KB at CRF 23 and 321 KB at CRF 28. On the CRF 23 version, OCR scored 28 for the first five frames, with later losses only from cropping. It is a plain mathematical zoom, but every pixel in it comes from your own image, so nothing can be invented.

Narrated walkthrough of the nine tests with the generated clips.

Cost and timing

Our account paid $0.103 per second at 720p and $0.129 at 1080p, which is the page’s top discount tier. The standard listed member rates are $0.1144 and $0.1432, so the same set would cost about 11% more. Text-to-video clips took 44 to 55 seconds, and 720p clips from a first frame took 76 to 115. Those are small samples from one session. Narration for the walkthrough video was extra and small. Every job with valid parameters completed on its first submission.

A checklist for SaaS clips

1. Decide first whether you need a model at all. A zoom on a screenshot is free and exact with ffmpeg.
2. On interface footage, tell the model that nothing changes, and repeat it. Never send a two-word prompt.
3. Do not ask it to show product behaviour. Record the real thing.
4. Never let it set your words. Composite them locally, which also makes localization simple.
5. Run OCR against an expected label list on every clip that shows UI. It takes seconds and catches errors a reviewer could miss.
6. Do not rely on counts, and treat multi-shot timings as approximate.
7. Strip the audio and re-encode before embedding. CRF 28 cut our test clip by more than 90%.
8. Log task IDs before polling, and set generous timeouts. Our slowest job took more than eight times longer than the next.

The bottom line

Kling 3.0 Turbo is a reasonable tool for the parts of a SaaS video that are not your product: abstract motion for an announcement, a human reaction shot, a textured opening. It generated those quickly, and with a firm prompt a first-frame screenshot held up well for five seconds. It is not a replacement for screen recording. It invented a click nobody asked for, missed one we did ask for, misspelled a headline with total confidence, and doubled a card count.

For the imaginary Quillrun team, the plan would be a hybrid. Record or zoom on real screens with local tools, set all words in HTML, and spend a few dollars a release on model-generated motion around them, with an OCR check on anything that shows the interface. We ran these tests through APIMart, using one key for the image, video and speech models involved.