Batch Short-Form Video with hailuo-2.3-fast/image-to-video on hiapi

Short-form video lives and dies on iteration speed. If you're feeding a TikTok or Reels pipeline, you don't need cinematic 4K output — you need a model that turns a product still into a usable clip in under a minute, cheap enough to run dozens of variants before picking a winner. That's the gap hailuo-2.3-fast/image-to-video is built for: the Fast Tier sibling of hailuo-2.3, priced and tuned specifically for high-volume, disposable-take workflows.

This guide walks through using it as a batch short-form video engine on hiapi: picking a source still, driving it through the async task API, verifying the schema quirks that will otherwise cost you a 400, and thinking about the economics of running it at TikTok/Reels scale.

What the model gives you

hailuo-2.3-fast/image-to-video takes a single still image and a prompt, and animates it into a short clip. It's on the hailuo-2.3-fast/image-to-video model page, and — like every model on hiapi — it's called through the unified /v1/tasks async endpoint: you POST a task, poll (or register a callback) until it's done, then pull the video from a short-lived output URL.

Verified against the live API at the time of writing:

• Input: one image (image_url) + a text prompt describing the motion you want
• Output: MP4, fixed durations of 6s or 10s (no arbitrary length)
• Pricing: flat per-video, not per-second — $0.27 for a 6-second clip, $0.46 for 10 seconds
• Turnaround: our test clip completed in about 80 seconds end-to-end (submit → success)

That per-video flat pricing is the detail that matters for batch work: a 6-second take costs the same whether your prompt nails the motion on the first try or you're on attempt four. At Fast Tier prices, running 5-6 variants of a hero shot to find the one with the cleanest motion still costs less than a single take on most premium video models. Confirm current numbers on the pricing page before you budget a batch — prices move.

If you need the full parameter reference, longer duration options, or side-by-side comparisons with the non-Fast hailuo-2.3 tier, see our hailuo-2.3-fast/image-to-video API integration tutorial — this guide focuses on the batch/workflow angle instead of the raw API reference.

The workflow: still → short clip

The short-form playbook is simple: start from a still you already have (product photography, a generated hero shot, a brand asset) and let the model add motion — a slow push-in, a subtle rotation, drifting atmosphere — rather than generating video from scratch. This keeps your visual identity locked (same product, same lighting, same composition) while producing something that isn't just a static post.

Here's a real run: a vertical (9:16) product still of a sneaker on a lit pedestal, driven with a motion prompt describing a slow push-in and gentle rotation.

VIDEO

The source still and full request:

curl -X POST https://api.hiapi.ai/v1/tasks \
  -H "Authorization: Bearer $HIAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "hailuo-2.3-fast/image-to-video",
    "input": {
      "prompt": "Slow smooth push-in on a chunky retro basketball sneaker in wolf-gray suede with volt yellow laces, floating above a wet concrete pedestal, subtle rotation revealing the side panel, mist drifting through teal-to-amber rim light, dust particles catching the light, stable cinematic camera movement, premium commercial product-video finish",
      "image_url": "https://static.hiapi.ai/gallery/2026/07/c2e71481d2eb81a7.jpg",
      "duration": "6",
      "prompt_optimizer": true
    }
  }'

Response:

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

Poll until it resolves:

curl https://api.hiapi.ai/v1/tasks/tk-hiapi-01KZ5FJV0TB8EYKDCV58FQ1F2X \
  -H "Authorization: Bearer $HIAPI_API_KEY"

{
  "status": "success",
  "output": [{"type": "video", "url": "https://temp.hiapi.ai/.../result.mp4", "expireAt": 1786421652}]
}

That output[0].url is temporary — download it immediately and move it to your own storage. Don't hot-link it or store it in a database field expecting a stable URL.

The input schema (verified against the live API)

The schema for this model is narrower than you might expect coming from other video models on the platform — no aspect ratio control, no resolution tiers, no seed.

Two gotchas that will cost you a 400 if you carry assumptions over from other models:

1. image_url is singular, not image_urls. Several other i2v models on hiapi take an array of reference images; this one takes exactly one. Send an array and you'll get a missing-field error, not a helpful coercion.
2. duration must be the string "6" or "10", not the number 6. Sending 6 as a number returns duration: got number, want string. And nothing outside that two-value enum is accepted — there's no arbitrary duration control on this tier.

Sending aspect_ratio, resolution, seed, or watermark — all common fields on sibling models — gets rejected outright with additional properties ... not allowed. The model inherits its aspect ratio from the input image, so if you need 9:16 output for Reels/TikTok, crop or generate your source still at 9:16 before you submit it (that's exactly what we did with the sneaker still above).

End-to-end Python

import requests
import time

API_BASE = "https://api.hiapi.ai/v1/tasks"
API_KEY = "your-api-key"

def make_short_clip(prompt: str, image_url: str, out_path: str, duration: str = "6"):
    resp = requests.post(
        API_BASE,
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "model": "hailuo-2.3-fast/image-to-video",
            "input": {
                "prompt": prompt,
                "image_url": image_url,
                "duration": duration,  # must be a string: "6" or "10"
                "prompt_optimizer": True,
            },
        },
        timeout=60,
    )
    resp.raise_for_status()
    task_id = resp.json()["data"]["taskId"]

    while True:
        task = requests.get(f"{API_BASE}/{task_id}",
                             headers={"Authorization": f"Bearer {API_KEY}"},
                             timeout=30).json()["data"]
        if task["status"] == "success":
            break
        if task["status"] == "fail":
            raise RuntimeError(task.get("error"))
        time.sleep(8)

    video_url = task["output"][0]["url"]  # temporary link — download immediately
    video_bytes = requests.get(video_url, timeout=120).content
    with open(out_path, "wb") as f:
        f.write(video_bytes)
    return out_path

For real batch runs — say, testing 6 prompt variants against the same source still to pick the cleanest motion — wrap this in a loop over your prompt list, and check in on each task_id independently rather than blocking sequentially; at ~80 seconds per clip, running several in parallel is what actually makes Fast Tier feel fast.

FAQ

Can I control the aspect ratio of the output? No — there's no aspect_ratio field on this model, and sending one returns a 400. Output follows the input image's aspect ratio, so prepare your source still at the ratio you need (9:16 for Reels/TikTok, 1:1 for feed posts) before submitting.

Why does my request fail with "got number, want string"? You sent duration as a JSON number. It must be the string "6" or "10" — those are the only two valid values.

Is this the same model as hailuo-2.3/image-to-video (non-Fast)? No — Fast Tier is a distinct, separately-priced model on hiapi with its own schema, tuned for speed and cost over the standard tier. See the full integration tutorial if you need the non-batch reference walkthrough.

Can I feed it a generated image instead of a real photo? Yes — the source still can come from any image model on hiapi (or elsewhere), as long as it's a publicly reachable URL. Using a still you've already produced for another format (a product hero shot, a poster) is often the fastest way to get short-form video without a separate creative pass.

Does pricing change with resolution? There's no resolution parameter on this model, so pricing is flat per duration regardless of the input image's resolution — $0.27 for 6s, $0.46 for 10s at time of writing. Confirm on the pricing page.

Takeaways

• hailuo-2.3-fast/image-to-video turns one still image into a 6s or 10s MP4, priced flat per video ($0.27 / $0.46) rather than per second — cheap enough to run several prompt variants per source image.
• The schema is intentionally narrow: prompt, image_url (singular), duration (string enum "6"/"10"), and optional prompt_optimizer — no aspect ratio, resolution, or seed control.
• Output inherits the input image's aspect ratio, so prepare your source still at 9:16 (or whatever ratio your platform needs) before submitting.
• The two most common integration mistakes are sending image_url as an array and sending duration as a number instead of a string.
• For batch short-form workflows, the flat per-video pricing and ~80-second turnaround make it practical to generate multiple takes and pick the best motion, rather than committing to one generation per asset.

Ready to try it on your own product shots? Head to the hailuo-2.3-fast/image-to-video model page to test a request directly, or check the full model catalog if you're comparing Fast Tier against other image-to-video options first.