arkennemasis fal · MiniMax Hailuo 02 Fast Image to Video · $0.017/s

Hailuo 02 is MiniMax's video model, and "Fast" here means 512p at $0.017 a second. Six seconds costs you ten cents. That's the cheapest moving picture in this pack by a wide margin, and it's the one you use to find out whether a shot works before spending real money on it.

Because there's no local option. Hailuo is a closed hosted service - you'll find people in the ComfyUI threads asking whether they can run clips like these locally and getting told, correctly, that Hailuo 02 is an online generator, full stop. Same situation as Veo or Sora: the API is the only door, and that's the whole reason a wrapper like this exists. So the honest use is: animate stills, draft a shot list, test whether your starting frame holds up in motion - then take the winner to the Pro endpoint at 1080p.

Inputs

• image - the starting frame. This is image-to-video, not text-to-video; the picture is the composition and the prompt is what happens in it.
• prompt - required. Motion and camera direction live here.
• duration - 6 or 10 seconds, default 6. At this price the difference is seven cents.
• prompt_optimizer - default true, meaning the model rewrites your prompt before generating. It's usually a help at this resolution; turn it off when a careful prompt keeps coming back changed.
• Plus the pack's max_cost_usd, reuse_identical_run, extra_json, max_concurrent.

Cost and mechanics

$0.017 per second, and the pack's estimate is computed from the duration box (or the real clip, where a media input is involved), so the badge and the pre-run check agree. max_cost_usd defaults to $20 and stops the run before anything is uploaded - at ten cents a clip you'll never hit it, which is the point of a guard that only fires when something has gone wrong upstream.

Then the standard fal flow: image uploaded to fal's CDN (free), one billed call, the node polls and shows status, and the MP4 lands in output/fal/fal-ai_minimax_hailuo-02-fast_image-to-video/. The fal wrapper in this pack adds no Python dependencies - it's standard-library HTTP.

Outputs

video (ComfyUI's native VIDEO type - wire it into a save node or downstream video node), video_path as a string, and info, the JSON with the fal request id, the cost estimate, saved files and fal's full answer. No seed output: you can't re-roll a video for free here.

Install

ComfyUI Manager → search comfyui-arkennemasis → install, or:

cd ComfyUI/custom_nodes
git clone https://github.com/Hishamahmer/comfyui-arkennemasis

Restart, then:

FAL_KEY=your-key-from-fal.ai/dashboard/keys

in the .env file in the folder holding run_nvidia_gpu.bat. There's no key field on the node on purpose, so a workflow you share can't carry your credential.

What to expect, honestly

512p is visibly soft. Not broken - soft, in the way an animatic is soft - and if you hand it a 1024×1024 starting frame, the model is going to reinterpret rather than preserve. That's fine for its job. Push it too far and you'll spend more time fighting mush than a 768p run would have cost you.

The prompt_optimizer default is worth noticing if your results feel like they drifted: turning it off is how you keep your prompt verbatim, and at this resolution the model's own rewrite often helps more than it hurts, so try both before deciding.

If a run fails, the other fal nodes in the same graph don't start - so a failure halfway through a 20-clip batch doesn't keep spending - and Cancel on the canvas cancels the request on fal too. The one that saves real money here: if ComfyUI is restarted mid-generation, the free Recover Result node collects the finished clip by id from output/fal/_requests.jsonl.