Kling AI Short Video API: Batch-Test TikTok Hooks

Why one clip isn't enough

If you're making short-form video for TikTok or Reels, the hook is the whole game — you have about a second before someone scrolls past. The problem is you can't know which opening beat will land until you see it cut against the others. A single generated clip answers "does this look good?" It doesn't answer "which of these five ideas actually stops the scroll?"

kling-3.0-turbo/text-to-video on hiapi is fast and cheap enough that you don't have to choose. Submit four or five hook variants of the same concept as one parallel batch, let them render at once, and pick a winner from real footage instead of a script read. This guide walks through that workflow end to end: designing variant prompts, submitting them in parallel through hiapi's async task API, and turning the output into a repeatable batch-production habit.

Summary:

• kling-3.0-turbo/text-to-video takes a prompt, duration (3–15s), resolution (720p or 1080p), and aspect_ratio — no other parameters, so every variant is just a prompt swap.
• hiapi's task API is async and stateless per call: submit all your variants back to back, then poll each taskId independently. Nothing blocks anything else.
• Four 5-second 9:16 clips at 720p cost $0.65 each — $2.60 for a full batch of hook candidates, cheaper than a single stock video license.
• Batching isn't free of curation: every clip still needs a human eyeball pass before anything ships, especially for lettering or fine motion.
• The pattern below scales past 4 clips — the only real ceiling is your account balance and how many hook ideas you can write.

The batch: one concept, four hooks

To make this concrete, here's a real batch — four 9:16 clips, same product (a small-batch cold brew), same 5-second runtime, same 720p resolution, four different opening beats. These are the actual outputs, not mockups.

Hook A — the pour. Locked-off macro shot on the pour itself, then a fast whip-pan up to a label. Tests whether a purely sensory opening (liquid, condensation, ice) is enough to hold attention before any branding shows.

Vertical phone-style shot, extreme close-up on dark cold brew coffee pouring in slow
motion over a tall glass of ice, condensation beading on the glass, morning window
light behind it. Camera holds locked-off the whole time, then the last quarter-second
whip-pans up to a hand-lettered 'SMALL BATCH' label. Photoreal, shallow depth of
field, warm kitchen counter background softly blurred.

Hook B — the reveal. A crate lid slides open on rows of bottled product. Tests a "behind the scenes" opening — the kind of curiosity hook that works when the product itself is visually interesting in bulk.

Vertical phone-style shot, a cafe worker's hand slides open a wooden crate lid to
reveal rows of amber cold brew bottles nestled in ice, steam-like cold mist drifting
up, warm string lights blurred in the background. Camera pushes in slightly as the
lid opens, quick energetic reveal, photoreal, handheld micro-shake for authenticity.

Hook C — the POV sip. First-person eyeline, glass rising toward camera on a sunny patio. Tests a lifestyle/aspirational opening instead of a product-first one.

Vertical phone-style POV shot from the drinker's eyeline, a glass of iced cold brew
coffee lifts up toward camera against a sunny outdoor cafe patio blurred behind it,
condensation dripping down the glass, ice cubes clinking and settling. Camera holds
steady as the glass rises, ends on the glass filling most of frame just before the
rim reaches camera. Photoreal, bright natural daylight.

Hook D — the action pour. Ice drops in first, then a fast pour fills the glass around it. Tests a higher-energy, more kinetic opening than Hook A's slow pour.

Vertical phone-style shot, ice cubes drop one by one in slow motion into an empty
glass on a dark wood counter, each cube splashing tiny droplets, followed by cold
brew coffee pouring in fast to fill the glass around them, motion blurring slightly
on the pour. Single continuous take, no cuts, photoreal, moody warm side lighting,
small depth of field.

Total cost for this batch: 4 clips × 5s × $0.13/s (720p) = $2.60. All four rendered from a single parallel submission round — more on the mechanics of that below.

The actual API mechanics

kling-3.0-turbo/text-to-video runs through hiapi's unified async task endpoint. There's no separate "batch" endpoint — the batching happens on your side, by submitting multiple independent task requests back to back and polling them concurrently.

Step 1 — submit every variant. Each submission is a plain POST /v1/tasks call:

curl -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-3.0-turbo/text-to-video",
    "input": {
      "prompt": "Vertical phone-style shot, extreme close-up on dark cold brew coffee pouring in slow motion over a tall glass of ice...",
      "duration": 5,
      "resolution": "720p",
      "aspect_ratio": "9:16"
    }
  }'

The response returns immediately with a taskId — it doesn't wait for the render. Loop this call once per variant and you've submitted the whole batch in a few seconds, well before the first clip finishes rendering.

Step 2 — poll each task independently. Each taskId is checked separately:

curl https://api.hiapi.ai/v1/tasks/<taskId> \
  -H "Authorization: Bearer $HIAPI_API_KEY"

Poll on an interval (a few seconds is reasonable) until status flips to success or fail. Because every task is independent, one slow render never blocks the others — you just keep a small dict of {taskId: status} and drop entries as they resolve. That's the entire "batch scheduler": no queue, no orchestration service, just a loop over independent async calls.

Step 3 — download immediately. On success, the response includes an output URL — but it's a signed, time-limited link, not a permanent one. Download the bytes as soon as the task resolves and store them yourself (R2, S3, wherever your pipeline lives). Don't leave clips sitting on the expiring URL.

The strict schema, in full:

Field	Type	Values
prompt	string	your scene description
duration	integer	3–15 (seconds)
resolution	string	720p or 1080p
aspect_ratio	string	16:9, 9:16, or 1:1

That's it — no extra fields are accepted. Which is actually what makes batching easy: every variant in a batch is just the same four keys with a different prompt (and, if you want, a different aspect_ratio for repurposing across platforms).

Writing hook variants that are actually different

The trap with batch generation is writing four prompts that are really the same clip with synonyms swapped — you'll get four near-identical renders and no real signal about which hook works. Vary on axes that change what the viewer actually sees in the first second:

• Camera behavior: locked-off vs. handheld micro-shake vs. a push-in vs. a POV rise. This changes the felt energy of the opening more than any subject-matter tweak.
• Point of view: third-person product shot vs. first-person POV vs. someone else's hands doing the action. POV shots tend to read as more native to short-form feeds.
• Reveal timing: does the product/label show in frame 1, or does the clip build toward it (Hook A's whip-pan reveal)? Cold-open-on-payoff and slow-build are genuinely different hooks, not variations of one.
• Motion energy: a slow deliberate pour (Hook A) vs. a fast kinetic one (Hook D) — same subject, opposite pacing, and pacing is often the actual variable that determines watch-through rate.

Four axes, one prompt each, is enough to get real signal from a batch. Stacking ten near-duplicate prompts just burns budget without adding information.

What batching does — and doesn't — solve

Batch generation answers "which idea is worth cutting into a real short?" It does not remove the need for a human pass on the output:

• Read every clip before shipping anything. kling-3.0-turbo renders motion and lighting convincingly, but any incidental on-screen text (like Hook A's label) still needs a human check — treat generated lettering the same way you'd treat any AI-rendered text: verify it, don't assume it.
• A batch is a screening round, not a final cut. The point is to throw away three ideas cheaply and invest further editing time only in the one that actually works.
• Costs scale linearly and predictably. At $0.13/s (720p) or $0.16/s (1080p), a batch of N clips at duration D costs N × D × rate — easy to forecast before you submit, unlike, say, a paid ad test where you don't know the cost until the campaign runs.

FAQ

How many variants should I put in one batch? Three to five is a practical range — enough to cover genuinely different hooks (camera behavior, POV, reveal timing, pacing) without generating near-duplicates. Past that, you're usually paying for redundant signal rather than new information.

Does resolution affect what I can test? No — 720p and 1080p only change price ($0.13/s vs $0.16/s) and file weight, not the aspect ratio or duration limits. For hook-testing rounds where you're going to discard most of the output, 720p is the cheaper choice; re-render the winner at 1080p if you need the higher-resolution file for final delivery.

Can I submit more than 4 or 5 at once? Yes — the task API doesn't cap how many independent tasks you submit, only your account balance and how fast you want results back. The submission loop and polling pattern described above scale the same way whether you're running 4 tasks or 40; you're just tracking more taskIds in the same loop.

Do the clips include audio? Yes — kling-3.0-turbo renders real ambient audio (splashes, pours, background room tone) even though there's no separate "with audio" pricing tier. Don't assume silence; check the actual output before layering in your own sound design.

What's the difference between this and just using the text-to-video prompt recipes guide? That guide is a single-clip prompt reference — good for learning what kling-3.0-turbo can render. This guide is about the production habit of generating several competing takes on one idea in parallel and picking a winner, which is the workflow that actually matters once you're shipping short-form content on a schedule.

Key takeaways:

• Batch generation with kling-3.0-turbo means submitting several prompt variants as independent async tasks, not a special "batch" API — the parallelism is just your own submit-then-poll loop.
• The model's schema is deliberately minimal (prompt, duration, resolution, aspect_ratio), which makes swapping prompts across a batch trivial.
• Vary hooks along camera behavior, POV, reveal timing, and motion energy — not synonyms — to get real signal from a batch.
• At $0.13/s (720p), a 4-clip hook-testing round costs a few dollars — cheap enough to run before every short-form post, not just for big campaigns.
• Batching narrows down which idea to pursue; it doesn't replace a human proofread pass on the winning clip.

Ready to run your own batch? Check current pricing and rate limits before a large run, or start from the kling-3.0-turbo/text-to-video model page for the full parameter reference. If you want single-clip prompt ideas first, the prompt recipes guide is a good starting library to remix into your own hook variants.