Kling AI Short Video via API: An End-to-End kling-3.0-omni Text-to-Video Workflow

Short-form video is a volume game: feeds reward accounts that post daily, and nobody can shoot, edit, and sound-design a clip a day by hand. kling-3.0-omni/text-to-video is one of the few models that covers the whole short-form checklist in a single API call — vertical 9:16 output, cinematic motion, multi-shot sequencing, and native synced audio — so the pipeline collapses to "write a prompt, poll a task, download an .mp4 you can post."

This guide walks the workflow end to end on the hiapi API: submitting the async task, designing prompts that survive a feed scroll, turning on native audio, stretching to multi-shot storytelling, and batching variants. Every clip embedded below is a real, unedited first output from the live API — generated for this article, with the exact prompt and settings shown next to it.

What you're working with

kling-3.0-omni/text-to-video (Kuaishou's Kling 3.0 Omni, text-to-video endpoint) runs on hiapi's async task interface. Pricing is per second of output and depends on resolution and whether you enable native audio. Rates below are from the hiapi pricing page at the time of writing:

Tier	Price per second	5s clip	10s clip
720p	$0.10	$0.50	$1.00
720p + audio	$0.143	$0.72	$1.43
1080p	$0.129	$0.65	$1.29
1080p + audio	$0.193	$0.97	$1.93
4K	$0.479	$2.40	$4.79

For feed-bound vertical video, 720p is the honest choice: TikTok and Reels recompress everything anyway, and it's the cheapest way to iterate on prompts. Save 1080p/4K for clips you'll also cut into other formats.

The input schema we validated live for this article: prompt (string), duration (integer seconds — we ran 5s and 10s), resolution (720p / 1080p / 4K), aspect_ratio (9:16 for vertical), and sound (boolean, off by default). One behavior worth knowing before you build around it: when you omit sound, the returned .mp4 has no audio track at all — not a silent track, no track. If your downstream editing pipeline expects an audio stream on every file, either always set sound: true or handle track-less files explicitly.

Submit → poll → download: the task lifecycle

Everything goes through POST /v1/tasks. Submit the job, get a task ID back immediately, poll until it finishes, then download the output. A 5-second 720p clip typically renders in a few minutes.

Submitting with curl:

curl -s -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-3.0-omni/text-to-video",
    "input": {
      "prompt": "Vertical short-form video. A barista in a sunlit specialty coffee bar pours a perfect rosetta latte art in one smooth motion, steam rising, morning light through the window, shallow depth of field, crisp photoreal detail, subtle slow push-in.",
      "duration": 5,
      "resolution": "720p",
      "aspect_ratio": "9:16"
    }
  }'

The response is immediate:

{"code": 200, "data": {"taskId": "tk-hiapi-01KWZYC1VKGV2CCSBK6AY9862H"}, "message": "success"}

Then poll GET /v1/tasks/{taskId} until status is success (or fail), and download output[0].url. Here's a complete Python helper — this is the actual pattern we used to generate every clip in this guide:

import json, subprocess, time, os

API = "https://api.hiapi.ai/v1/tasks"
TOKEN = os.environ["HIAPI_API_KEY"]

def submit(input_fields: dict) -> str:
    payload = {"model": "kling-3.0-omni/text-to-video", "input": input_fields}
    out = subprocess.run(
        ["curl", "-s", "-X", "POST", API,
         "-H", f"Authorization: Bearer {TOKEN}",
         "-H", "Content-Type: application/json",
         "-d", json.dumps(payload)],
        capture_output=True, text=True, timeout=70).stdout
    return json.loads(out)["data"]["taskId"]

def wait(task_id: str, timeout_s: int = 900) -> dict:
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        out = subprocess.run(
            ["curl", "-s", f"{API}/{task_id}",
             "-H", f"Authorization: Bearer {TOKEN}"],
            capture_output=True, text=True, timeout=40).stdout
        task = json.loads(out)["data"]
        if task["status"] == "success":
            return task
        if task["status"] == "fail":
            raise RuntimeError(f"task failed: {task.get('error')}")
        time.sleep(8)
    raise TimeoutError(task_id)

task_id = submit({
    "prompt": "...",
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
})
task = wait(task_id)
video_url = task["output"][0]["url"]
subprocess.run(["curl", "-s", "-o", "clip.mp4", video_url], timeout=120)

One operational detail that matters in production: the output[0].url you get back is a time-limited signed link (it carries an expiry). Download the bytes as soon as the task succeeds and store them on your own bucket or CDN — never save the raw task URL in your database or CMS.

Prompt design for a 3-second hook

Short-form lives or dies in the first second on screen. The prompt pattern that consistently works for vertical hooks: one subject, one continuous satisfying motion, light described explicitly, and a camera move stated in camera language. Here's the exact prompt from the curl example above, and the clip it produced:

Vertical short-form video. A barista in a sunlit specialty coffee bar pours a
perfect rosetta latte art in one smooth motion, steam rising, morning light
through the window, shallow depth of field, crisp photoreal detail, subtle
slow push-in.

Real output — kling-3.0-omni/text-to-video, 5s @ 720p, 9:16, no audio. First take, unedited.

What each ingredient is doing:

• "Vertical short-form video" up front anchors framing decisions, not just the pixel ratio — the model composes for a phone screen.
• One continuous motion ("pours ... in one smooth motion") gives the model a single arc to render instead of inviting random cuts.
• "Subtle slow push-in" is a real camera instruction. Vague mood words ("dynamic", "engaging") make the model improvise; camera vocabulary keeps it on rails.
• Light gets a sentence ("morning light through the window") — lighting is the difference between "AI clip" and "shot on a real set."

Native audio: set sound: true, describe the soundscape

Kling 3.0 Omni's headline feature is native synced audio — the model renders a soundtrack that matches the visuals, which for food, ASMR, and street content is most of the retention. Two things must both happen: set "sound": true in the input (it's billed at the +audio rate, $0.143/s at 720p), and describe the audio in the prompt the way you describe the visuals:

Vertical short-form video. Close-up of a street food vendor's wok at night:
diced garlic and chili hit sizzling oil with a burst of steam, flames lick up
the wok's edge as the vendor tosses noodles in rhythmic flips, neon signs
glowing bokeh in the background. Handheld feel, appetizing, high energy.
Native audio: loud sizzle, wok clangs, distant street chatter.

Real output — kling-3.0-omni/text-to-video, 5s @ 720p, 9:16, sound: true. Turn the volume on: the sizzle and wok hits are model-generated and synced to the tosses.

The "Native audio:" suffix pattern — a short comma-separated list of the two or three sounds that matter — reliably beats prose like "with realistic sound effects." Name the sounds; the model syncs them to the matching visual events.

We verified the billing boundary with ffprobe on the actual outputs: clips submitted without sound contain a single H.264 video stream, while sound: true clips carry an additional AAC audio track. You only pay the audio premium on the clips where you asked for it.

Multi-shot storytelling in one prompt

Omni's other differentiator is multi-shot sequencing: you can script explicit cuts inside a single generation instead of stitching three separate clips. Number the shots in the prompt and give the sequence one shared color grade so it reads as an edit, not an accident:

Vertical short-form video, three-shot sequence. Shot 1: a young woman in a
yellow rain jacket steps out of a subway exit into light rain, opens a clear
umbrella. Shot 2: close-up of her boots splashing through a neon-reflecting
puddle in slow motion. Shot 3: she stops at a food cart, smiles as warm steam
drifts past, city lights bokeh behind. Cohesive teal-and-amber grade,
cinematic handheld energy. Native audio: soft rain, city ambience, distant
traffic hum.

Real output — kling-3.0-omni/text-to-video, 10s @ 720p, 9:16, sound: true. Three scripted shots, one generation: $1.43.

Budget roughly three seconds per shot — a 10-second duration fits a three-beat story. The recurring anchor (the yellow rain jacket) is what holds identity across cuts; give every multi-shot prompt one loud visual constant, or the subject will drift between shots.

Batch production: one template, many variants

The economics get interesting at volume. A week of daily posts is one prompt template with a variable slot, submitted concurrently — the tasks render in parallel, so a batch finishes in roughly the time of one clip. We took the latte hook template and swapped the subject:

Vertical short-form video. A ceramic bowl of matcha being whisked into a vivid
green froth with a bamboo whisk, in a sunlit specialty tea bar, steam rising,
morning light through the window, shallow depth of field, crisp photoreal
detail, subtle slow push-in.

Real output — same template as the latte clip, one variable changed. 5s @ 720p, 9:16: $0.50.

The push-in, the window light, and the shallow depth of field carried over untouched — which is exactly what you want for a visually consistent account. In code, batching is just submitting before you wait:

TEMPLATE = ("Vertical short-form video. {subject}, in a sunlit specialty {venue}, "
            "steam rising, morning light through the window, shallow depth of field, "
            "crisp photoreal detail, subtle slow push-in.")

VARIANTS = [
    {"subject": "A barista pouring a perfect rosetta latte art in one smooth motion", "venue": "coffee bar"},
    {"subject": "A ceramic bowl of matcha being whisked into a vivid green froth with a bamboo whisk", "venue": "tea bar"},
    {"subject": "A croissant being pulled apart to reveal steaming, glossy layers", "venue": "bakery"},
]

task_ids = [submit({
    "prompt": TEMPLATE.format(**v),
    "duration": 5,
    "resolution": "720p",
    "aspect_ratio": "9:16",
}) for v in VARIANTS]          # all rendering in parallel

clips = [wait(tid) for tid in task_ids]

Cost planning at 720p: a 30-clip month of 5-second silent hooks is $15; the same month with native audio is $21.45. Even an aggressive schedule — daily 10-second audio clips — lands at $42.90/month, less than a single hour of a video editor's time. Poll results as they land, and treat a fail status on one task as a retry for that variant only, not the batch.

Everything in this article cost $3.15 in video generation: four clips, 25 seconds of footage, all first takes.

Where to go from here

You now have the full loop: submit a 9:16 task, poll it, pull the .mp4, and scale it with a template. A few pointers for the next step:

• Grab an API key and the full endpoint reference in the hiapi docs — the task lifecycle above is the same for every video model on the platform.
• Check current per-second rates for all tiers on the pricing page before you budget a big batch.
• If you're choosing between models for this use case, we ran the same short-form workflow on a budget model in Short-Form Video with seedance-2.0-mini — useful as a price/quality baseline against Kling.

Start with one $0.50 probe clip of your own subject, keep the prompt ingredients that survive contact with the feed, then turn the template into a batch on the kling-3.0-omni/text-to-video model page.