Using Seedance-2.0-Fast to Make Short-Form Video via the hiapi API

TL;DR

• What this is: a complete workflow for producing vertical, TikTok/Reels-style clips with seedance-2.0-fast through the hiapi API — from your first async task call to a batch script that renders a full week of posts. The clip embedded below was generated with the exact request shown in this guide.
• Why this model for short-form: native 9:16 output, durations from 4–15 seconds, and 720p renders at $0.1772/second — a 5-second vertical clip costs about $0.89 (live pricing). A 480p draft tier at $0.0843/second makes it cheap to iterate on a hook before committing to a final render.
• Verified API facts: prompt, resolution (480p | 720p), and duration (integer, 4–15) are required. aspect_ratio accepts 1:1, 4:3, 3:4, 16:9, 9:16, 21:9, adaptive. Image-to-video takes a still through image_urls. Everything runs through the unified async /v1/tasks endpoint — no separate video-specific API to learn.
• Workflow: draft at 480p to lock the concept, re-render the keeper at 720p, and fan out multiple prompts in parallel since task submission doesn't block.

Why seedance-2.0-fast fits the short-form loop

Short-form content is a volume game — you're rarely shipping one clip, you're shipping a queue of them and keeping the ones that land. That changes what you actually need from a video model: fast, cheap, vertical-native output more than raw fidelity. seedance-2.0-fast is built around exactly that trade-off:

• Per-second pricing keeps iteration affordable. At 480p a 4-second draft costs about $0.34; a 5-second clip like the one below runs $0.42 at 480p or $0.89 at 720p. Because billing is purely duration × rate, duration is your only cost lever — there's no separate "quality" surcharge to budget around (verified against the live pricing page).
• Native 9:16. You render vertical directly through aspect_ratio, instead of cropping a 16:9 clip and losing the composition your prompt described.
• Reference-video mode is cheaper, not more expensive. Passing a reference_video_urls clip for style/motion guidance drops the rate to $0.1072/s at 720p and $0.0486/s at 480p — useful once you've found a look you want to repeat across a batch.

If you're publishing a hero piece rather than daily volume, the workflow below still applies — see our companion piece on seedance-2.0-fast for API integration for the broader model walkthrough.

Setup

You need an hiapi API key — no SDK required:

export HIAPI_API_KEY="sk-..."

Every video model on hiapi runs through the same async task endpoint: POST https://api.hiapi.ai/v1/tasks returns a taskId immediately, and you poll GET /v1/tasks/{taskId} until it resolves. Full reference is in the docs.

Your first vertical clip

The minimum valid request needs prompt, resolution, and duration. Add aspect_ratio: "9:16" for a short-form frame:

curl -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "seedance-2.0-fast",
    "input": {
      "prompt": "Close-up vertical shot: hands stacking a golden pancake on top of a tall stack of pancakes on a glass plate, steam rising, on a rustic wooden table in a sunlit kitchen. Warm morning light streams in from the left. Then a stream of honey pours slowly over the top pancake, glistening in the light, steam continuing to rise. Cozy, natural, handheld-feel camera, shallow depth of field, warm color grade. No text overlays.",
      "resolution": "720p",
      "aspect_ratio": "9:16",
      "duration": 5
    }
  }'

The response returns instantly with a task ID:

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

Poll until status is success, then download output[0].url right away — the URL is time-limited. Here's the actual clip that exact request produced:

VIDEO

That render came back at 720×1280 (a clean 9:16), ran just over 5 seconds, and billed $0.886 — exactly 5 × $0.1772, confirming the per-second rate in practice, not just on the pricing page.

The input schema, verified against the live API

seedance-2.0-fast's schema is strict — send an unsupported field and you get a 400, not a silently-ignored parameter:

Omit a required field and the task is rejected before anything is created — no charge for a malformed request. Match the field names in this table exactly; short-form scripts that were written against a different video model (a motion_strength, a seed, a first_frame_url) will 400 here rather than being ignored.

A reusable Python function

Submit, poll, download — about 30 lines covers a production loop:

import os, time, requests

API = "https://api.hiapi.ai/v1/tasks"
HEADERS = {"Authorization": f"Bearer {os.environ['HIAPI_API_KEY']}"}

def submit(prompt: str, duration: int = 5, resolution: str = "720p",
           aspect_ratio: str = "9:16", **extra) -> str:
    r = requests.post(API, headers=HEADERS, json={
        "model": "seedance-2.0-fast",
        "input": {"prompt": prompt, "duration": duration,
                  "resolution": resolution, "aspect_ratio": aspect_ratio, **extra},
    }, timeout=60)
    data = r.json()
    task_id = (data.get("data") or {}).get("taskId")
    if not task_id:
        raise RuntimeError(f"submit failed: {data}")
    return task_id

def wait(task_id: str, timeout_s: int = 900) -> dict:
    deadline = time.time() + timeout_s
    while time.time() < deadline:
        task = requests.get(f"{API}/{task_id}", headers=HEADERS, timeout=30).json()["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)

def make_clip(prompt: str, out_path: str, **kw):
    task = wait(submit(prompt, **kw))
    url = task["output"][0]["url"]          # time-limited — download immediately
    with open(out_path, "wb") as f:
        f.write(requests.get(url, timeout=120).content)

A 5-second 720p render typically finishes in one to two minutes; budget up to ~10 minutes at peak load before treating it as a timeout.

Image-to-video: start from a fixed frame

For product or brand-led shorts, prompt drift is the real risk — you want your product or plate in frame, not the model's interpretation of it. image_urls solves this: generate or photograph a still, then animate it.

task_id = submit(
    "The pancake stack settles gently as steam continues to curl upward, "
    "then honey begins pouring from just outside frame, first drops landing "
    "on the top pancake. Slow, steady handheld-feel motion, warm morning light.",
    duration=5, resolution="720p", aspect_ratio="9:16",
    image_urls=["https://your-cdn.example/pancake-still.jpg"],
)

Composition, lighting, and subject placement stay locked to your reference still — the prompt only needs to describe the motion that happens next. This is the move for any short where the opening frame matters more than the model's own instincts (a plated dish, a product shot, a branded set).

Batching a day's worth of clips

Because /v1/tasks is async, batch production is just: submit everything, then collect.

briefs = [
    ("hook-pancakes", "Close-up vertical shot: hands stacking a golden pancake ..."),
    ("hook-latte",    "Vertical shot: steam rising off a fresh latte as milk is poured ..."),
    ("hook-citrus",   "Vertical macro shot: a knife slicing through a citrus fruit ..."),
]

tasks = {name: submit(p, duration=5) for name, p in briefs}   # fan out
for name, tid in tasks.items():                                # collect
    result = wait(tid)
    url = result["output"][0]["url"]
    open(f"{name}.mp4", "wb").write(requests.get(url, timeout=120).content)

Cost stays predictable because billing is strictly duration × rate:

A workflow that holds up in practice: draft every idea at 480p, keep the ones worth publishing, and only re-render those at 720p. Once you've found a look worth repeating, reference_video_urls locks the style at a lower per-second rate than a fresh 720p render.

Prompting for the feed

What actually shaped the output across test renders, specific to short-form:

• Describe the frame as vertical, and set aspect_ratio: "9:16" to match. A prompt written for a 16:9 scene gets center-cropped when forced into 9:16; describing a close, vertical composition up front (as in the pancake clip above) keeps the subject filling the frame.
• Lead with the motion, not the setup. The opening moment of a feed clip needs to already be doing something — a hand already mid-stack, honey already starting to pour — not a slow establishing shot before the payoff.
• Keep it to one clear action per clip. The 5-second render above does exactly two things in sequence (stack, then pour) and reads cleanly; stacking three unrelated actions into one short clip tends to blur all of them.
• State the lighting and material explicitly. "Warm morning light," "steam rising," "glistening" — concrete sensory detail is what separates a specific, appetizing render from a generic one.

FAQ

Is seedance-2.0-fast good for TikTok and Reels specifically? Yes — native 9:16 support and per-second pricing (rather than a flat per-clip fee) make it well suited to posting cadence, where you're rendering several short options and keeping the strongest one.

How much does a single short video cost? At 720p, cost is duration_in_seconds × $0.1772. A 5-second clip is $0.886; a 10-second clip is $1.772. At 480p the rate drops to $0.0843/s. Always confirm current rates on the pricing page before budgeting a batch.

Can I animate a still image instead of generating from text alone? Yes, via image_urls in the request — see the image-to-video section above. This is the more reliable path when a specific product, plate, or set needs to appear exactly as shot.

What's the shortest and longest clip I can generate? duration accepts integers from 4 to 15 seconds. There's no fractional-second support.

Does resolution affect anything besides pixel dimensions and price? Not in the schema itself — resolution only controls output size and the per-second rate. Composition and motion are driven entirely by the prompt and aspect_ratio.

Wrap-up

Short-form video with seedance-2.0-fast comes down to one async endpoint, three required fields, and per-second pricing that rewards iterating before you commit: draft vertical concepts at 480p, lock the winner's opening frame with image_urls if a specific product or subject needs to appear exactly right, and re-render the keeper at 720p. Grab an API key and start with the request at the top of this guide — the seedance-2.0-fast model page has the full parameter reference and current pricing to take it from there.