Editorial Modellix cover reading Hailuo 02 API on two bold lines over a dark amber technical architecture with an amber key and cyan rim light

The short answer: the Hailuo 02 API is real, but not one API

“Hailuo 02 API” is a search term for a model that ships under different names, endpoints, and billing units depending on where you call it. MiniMax’s own pay-as-you-go page still lists MiniMax-Hailuo-02 and still charges for it as of August 7, 2026. Aggregators expose the same underlying model as minimax/hailuo-02, fal-ai/minimax/hailuo-02/standard/image-to-video, or minimax-hailuo-02 — and they bill per second, per 10 seconds, or per completed video. The first step of any integration is therefore not writing code; it is deciding which route you mean.

This guide walks through the model identity, the pricing units, Python and curl examples, the parameters that matter, the errors you will actually hit, and how to choose between MiniMax direct and an aggregator route. Every price below was read from the live source page on August 7, 2026, and every figure carries its source.

Modellix is an aggregator and has a commercial interest in this comparison: we offer Hailuo 02 routes on our own per-second pricing. None of the numbers below support a blanket “one route is cheapest” conclusion — the winner changes by cell, and the route terms differ. Compare the same model name, resolution, duration, and billing unit before you pick.

Which model are you actually calling? Hailuo 02 vs 2.3 vs H3

MiniMax now documents video generation around its newer MiniMax H3 model, and its model table lists Hailuo 02 under legacy video models alongside Hailuo 2.3 and 2.3 Fast. “Legacy” here does not mean removed: the official pay-as-you-go page still prices Hailuo 02, and every major aggregator still serves it. It means the model is stable, documented, and not the current marketing headline.

The API-style name is MiniMax-Hailuo-02. Model cards that summarize MiniMax’s model table — like this Hailuo 02 reference — describe text-to-video output at 768P or 1080P and image-to-video at 512P, 768P, or 1080P, at 24 fps, with 6- or 10-second clips, plus a First & Last Frame workflow documented specifically for this model. You will also see the model called “Hailuo 2” and “Hailuo AI 02” — same model, different labels.

The practical confusion is between 02 and 2.3. Both are built on the same architecture and priced identically on the official page; 2.3 is retuned for human motion, micro-expressions, and stylized art, while 02 is the physics-and-motion pick with longer 1080p takes and the Hailuo variant with a first/last-frame transition workflow. If you are choosing between them for a pipeline, our Hailuo AI API guide covers that decision in depth. This article assumes you have already chosen Hailuo 02 and need to integrate it.

Hailuo 02 API pricing: match the billing unit before comparing

Pricing for Hailuo 02 is published in at least three units. MiniMax direct charges a flat rate per completed video. fal.ai charges per second. AIMLAPI charges per 10 seconds. Modellix charges per second. All of these can describe the same 6-second clip, and none of them is directly comparable until you normalize.

Route Published unit 768P, 6s 768P, 10s 1080P, 6s Billing note
MiniMax direct (MiniMax-Hailuo-02) per video $0.28 $0.56 $0.49 Flat per completed video; read from the official page
fal.ai Standard / Pro per second $0.045/s → $0.27 — $0.08/s → $0.48 fal’s docs cap Standard at 6s output
AIMLAPI per 10 seconds $0.4368 $0.728 — Listed as “$0.728 / 10 sec tokens”, resolution not stated; 6s cell prorated from the 10s rate
Modellix (hailuo-02-t2v / i2v) per second $0.054/s → $0.324 $0.0672/s → $0.672 $0.106/s → $0.636 Per-second meter, resolution-dependent

Sources, all accessed August 7, 2026: MiniMax Pay as You Go, fal.ai Hailuo 02 model page, AIMLAPI Hailuo 02 model page, and the Modellix Hailuo 02 T2V model page. Cells marked “→” are derived arithmetic, not published prices: the fal and Modellix rows multiply the published per-second rate by the clip length, and the AIMLAPI 6s cell prorates its per-10-seconds rate (0.6 × $0.728).

Modellix model page for minimax/hailuo-02-i2v showing the six parameters and a per-second pricing table by resolution and duration

Modellix model page for minimax/hailuo-02-i2v, captured from modellix.ai on August 7, 2026. It publishes per-second pricing by resolution and duration — one of the billing units used across Hailuo 02 routes.

Three consequences follow from this table:

  1. Normalize before you compare. A “price” without its unit is noise. Divide per-10s prices by 10, multiply per-second prices by your clip length, and keep per-video prices as-is.
  2. The winner changes by cell. On 768P 6s, fal’s list price is the lowest of the four published figures; on 1080P 6s, MiniMax direct is. There is no consistent cheapest route in the current public data.
  3. Terms differ beyond price. fal documents a 6-second output cap for Standard, MiniMax direct is per-video at fixed combos, and Modellix’s own Hailuo guide notes that 10-second jobs run at 768P while 1080P caps at 6 seconds — its live pricing table also shows a 10s/1080P cell, so confirm the exact combination against the live page before budgeting.

For a fuller treatment of how MiniMax’s billing surfaces fit together — pay-as-you-go, credits, and video packages — see our MiniMax pricing breakdown.

Quick start: generate a video with the Hailuo 02 API

The fastest path to a working Hailuo 02 integration is the async submit-and-poll pattern. MiniMax’s official workflow is: create a generation task and receive a task_id, poll the task, then download the video from the returned URL. Aggregator routes follow the same shape with their own endpoints and keys.

Below is a Python example against Modellix’s documented Hailuo 02 text-to-video endpoint, using only the standard library plus requests:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import time
import requests

API_BASE = "https://api.modellix.ai/api/v1"
API_KEY = "YOUR_MODELLIX_API_KEY"  # create one in the console

headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

# 1. Submit the job
resp = requests.post(
    f"{API_BASE}/minimax/hailuo-02-t2v/async",
    headers=headers,
    json={
        "prompt": "A cinematic slow aerial drift over a sea of golden clouds at sunrise, gentle motion, warm volumetric light",
        "duration": 6,
        "resolution": "1080P",
        "prompt_optimizer": True,
    },
)
resp.raise_for_status()
task = resp.json()["data"]
task_id = task["task_id"]
poll_url = task["get_result"]["url"]
print("submitted:", task_id)

# 2. Poll with backoff: first check at 15s, then 5s up to 30s, max 12 attempts
attempt, wait = 0, 15
while attempt < 12:
    time.sleep(wait)
    status = requests.get(poll_url, headers=headers).json()["data"]["status"]
    print(f"attempt {attempt + 1}: {status}")
    if status in ("success", "failed"):
        break
    attempt += 1
    wait = min(30, 5 * 2**attempt)

# 3. On success the output video lives at data.result.resources[].url —
#    each resource carries type/url/width/height/format/role; take the video one.
if status == "success":
    data = requests.get(poll_url, headers=headers).json()["data"]
    video_url = next(
        r["url"] for r in data["result"]["resources"] if r.get("type") == "video"
    )
    print("video:", video_url)
else:
    raise RuntimeError(f"Hailuo 02 job ended in state: {status}")

The same flow with curl, against the same endpoint:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 1. Submit the job
curl --request POST \
  --url https://api.modellix.ai/api/v1/minimax/hailuo-02-t2v/async \
  --header 'Authorization: Bearer YOUR_MODELLIX_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "prompt": "A cinematic slow aerial drift over a sea of golden clouds at sunrise",
    "duration": 6,
    "resolution": "1080P",
    "prompt_optimizer": true
  }'

# 2. Poll the result URL returned in step 1 (data.get_result.url)
curl --request GET \
  --url https://api.modellix.ai/api/v1/tasks/{task_id} \
  --header 'Authorization: Bearer YOUR_MODELLIX_API_KEY'

For image-to-video, switch the endpoint to /minimax/hailuo-02-i2v/async and add the reference image:

1
2
3
4
5
6
7
8
9
10
resp = requests.post(
    f"{API_BASE}/minimax/hailuo-02-i2v/async",
    headers=headers,
    json={
        "first_frame_image": "https://your-cdn.example.com/product-shot.jpg",
        "prompt": "The camera orbits the product slowly, soft studio lighting",
        "duration": 6,
        "resolution": "1080P",
    },
)

The same pattern — submit, poll get_result.url, collect the terminal state — is the documented Modellix contract for Hailuo 02, and it mirrors the official MiniMax workflow of create-task, poll, and download. The Modellix Hailuo 02 T2V model page lists the current parameters and per-second rates if you are reading this after the figures above have moved.

If you are calling MiniMax directly instead, the workflow is the same three steps against platform.minimax.io with a standard Open Platform API key; MiniMax’s video generation guide is the current reference. Note that this page now documents MiniMax H3 as the primary model — another sign that Hailuo 02 is the stable legacy option, not the moving target.

Parameters that actually change your output

Hailuo 02’s parameter set is small, and most of the leverage is in three fields.

Parameter Type What it does Route notes
prompt string Video content description; camera-control instructions work Required on every route
first_frame_image / image image URL or Base64 Starting frame for image-to-video; without it the call is text-to-video Required for I2V on Modellix and fal; AIMLAPI supports both modalities
duration integer Clip length in seconds 6 or 10 on MiniMax/Modellix/vmodel; fal documents up to 6s
resolution string Output resolution 512P/768P/1080P on Modellix I2V; T2V starts at 768P; check the combination with duration
prompt_optimizer boolean Rewrites thin prompts into more directable ones Default true on Modellix; promptOptimizer on Pollo
fast_pretreatment boolean Fast pretreatment, only effective with prompt_optimizer=true Modellix-specific

Two route-specific constraints are worth checking before you send an image: fal documents input aspect ratio between 2:5 and 5:2, a minimum of 300px on the shorter side, and a 20MB file limit; Pollo’s reference additionally exposes an imageTail (last-frame) input alongside the first frame. The same model can have different input rules on different routes, so treat the route’s own docs as the contract. Pollo’s Hailuo 02 reference and the fal model page are the two most explicit parameter references currently ranking for this query.

The Modellix Hailuo 02 I2V model page shows the same parameter set with the live per-second pricing table for each resolution and duration cell.

Pollo Hailuo 02 API reference showing the POST endpoint, the input object with image, imageTail, prompt, promptOptimizer, resolution, and length fields

Pollo’s Hailuo 02 API reference, captured from docs.pollo.ai on August 7, 2026. It documents the endpoint and the input object, including the imageTail last-frame field that most routes do not expose.

Async lifecycle, errors, and the failure modes nobody documents

Video generation is asynchronous on every route: submit a job, poll for a terminal state, retrieve the output URL. The part that trips up integrations is not the happy path — it is sorting responses into the right buckets and stopping at the right time.

Sort every poll response into three buckets, as Modellix’s Hailuo guide documents:

Bucket Status examples Action
In progress pending, processing Back off and re-poll with exponential backoff plus jitter
Blocked invalid_input, content_policy Fix the input; do not retry as-is
Terminal success, failed Collect the result or surface the error; stop polling

A workable cadence: first check at 15 seconds, then exponential backoff from 5s capped at 30s, with a maximum of 12 attempts, and roughly 20% jitter when running concurrent jobs. The example in the previous section implements exactly that loop.

The errors you will actually meet, in rough order of frequency:

  • 401 / invalid key — you are hitting the wrong route’s auth scheme. Official MiniMax uses standard Open Platform keys; fal uses FAL_KEY; Pollo uses an x-api-key header. An aggregator key does not work on another aggregator’s endpoint.
  • Invalid model name — MiniMax-Hailuo-02 (official), minimax/hailuo-02 (AIMLAPI-style), fal-ai/minimax/hailuo-02/standard/image-to-video (fal), and minimax-hailuo-02 (Pollo) are all real, and none is interchangeable. Pasting the wrong slug returns a model-not-found error that looks like a typo and is actually a route mismatch.
  • Duration or resolution out of enum — duration accepts 6 or 10 (6 on some routes), and a 1080P + 10s combination is rejected by at least one documented route. Validate locally before submitting; a rejected render still costs a polling cycle.
  • Image errors — oversized files, wrong aspect ratio, or a reference URL that does not resolve. Preflight the image URL with a HEAD request before submission.
  • Rate limits — most routes publish no public RPM for Hailuo 02; treat the 429 you eventually get as a backoff signal, not a bug.

None of the currently ranking model pages documents these failure modes — the closest is a generic try/catch on the fal page. If you are building a production queue, log at minimum the task_id, your correlation ID, the input hash, the output URL, and the elapsed time, and pin the model version by name so a future model update cannot silently change your output style or your cost slope.

Direct MiniMax vs aggregators: how to choose a route

The decision is not “MiniMax vs everyone else”; it is which contract fits your integration. The route table below is the same model viewed through four contracts, with the verified-as-of date in each row’s source.

Route Model ID Billing unit Key/auth Best when
MiniMax direct MiniMax-Hailuo-02 per video Open Platform API key You already run MiniMax direct for other models and want the single-vendor source of truth
fal.ai fal-ai/minimax/hailuo-02/standard/image-to-video per second FAL_KEY You are already on fal’s queue API and want their storage/webhook tooling
AIMLAPI minimax/hailuo-02 per 10 seconds Bearer key You want an OpenAI-compatible base URL and one key across many models
Modellix minimax/hailuo-02-t2v / -i2v / -fl2v per second Bearer key You want the same submit-poll contract across Hailuo, Kling, Wan, Seedance and the rest, with per-job cost logging

Aggregators earn their keep on the workflow axis, not on a universal price advantage: one key, one billing dashboard, and consistent async patterns across models. The Modellix MiniMax provider page lists the current routes, and our MiniMax free API guide separates documented free endpoints from paid video access if your budget case depends on it.

The honest boundary: if your only requirement is a single Hailuo 02 price sheet and you have no other model needs, MiniMax direct is the simplest source of truth. The moment your product spans several video or image models, the per-vendor accounts, keys, response schemas, and polling logic multiply — that is the workflow cost an aggregator removes. Choose the route that minimizes the workflow surface for your product, then verify its live price cell.

FAQ

Is the Hailuo 02 API still available, or has it been deprecated?

As of August 7, 2026, MiniMax-Hailuo-02 is still listed and priced on MiniMax’s official pay-as-you-go page, and major aggregators still serve it. MiniMax’s model table classifies it as a legacy video model — stable and documented, but no longer the marketing headline, which is now MiniMax H3. “Legacy” does not mean shut down; verify the live page before you plan around it.

What is the difference between the Hailuo 02 API and the Hailuo 2.3 API?

They share the same architecture and the same official per-video prices. Hailuo 2.3 is retuned for human motion, micro-expressions, and stylized art; Hailuo 02 is the physics-and-motion pick with longer 1080p takes and the first/last-frame transition workflow. There is also a cheaper 2.3 Fast tier on the official page. Our Hailuo AI API guide compares the two in depth.

How much does one Hailuo 02 video cost?

On MiniMax direct, $0.28 for 768P 6s, $0.56 for 768P 10s, and $0.49 for 1080P 6s (as of August 7, 2026). Per-second routes price the same clip differently: fal lists $0.045/s (Standard, 768P) and $0.08/s (Pro, 1080P), and Modellix lists $0.054–$0.106/s depending on resolution and duration. Normalize the unit, then compare.

Can I use the Hailuo 02 API for free?

There is no documented free tier for Hailuo 02 on MiniMax’s official pay-as-you-go page as of August 7, 2026. Some aggregators pair new accounts with a small starter credit that is enough for one or two test clips — AIMLAPI advertises a free-credit start on its signup page, and Modellix’s terms are worth checking on its own signup page. Treat any credit as a test budget, not a production cost baseline.

Does the Hailuo 02 API support image-to-video?

Yes. Image-to-video takes a first-frame image plus a prompt, and MiniMax documents a First & Last Frame workflow for this model specifically. On aggregator routes the parameter is first_frame_image (Modellix), image (Pollo), or image_url (fal), and the endpoint slug usually contains i2v or a variant.

What does the model name “MiniMax-Hailuo-02” mean?

It is the official API-style model name on MiniMax’s platform. Aggregators expose the same model under their own IDs — minimax/hailuo-02 on AIMLAPI, fal-ai/minimax/hailuo-02/standard/image-to-video on fal, minimax-hailuo-02 on Pollo. The names are not interchangeable; the model ID is part of the route contract.

Is Modellix cheaper than calling MiniMax directly?

Not as a blanket statement, and the current data does not support it. On the 768P 6s cell, fal’s list price is the lowest of the published figures; on 1080P 6s, MiniMax direct is. Modellix’s argument is workflow, not a universal price floor: one key, one billing surface, and the same async contract across many models, with per-job cost logging. Compare your exact cell before deciding.

Where can I find a Hailuo 02 API example in Python?

The quick-start section of this guide is a complete requests implementation of the submit-and-poll pattern, written against the documented API response contract. The official MiniMax workflow (create task, poll, download) is described in MiniMax’s video generation guide, and the AIMLAPI model page and Pollo reference both carry Python examples against their own endpoints.

Where can I find Hailuo 02 API examples on GitHub?

GitHub is where most working Hailuo 02 API code lives, but treat any repository as a starting point: model IDs, endpoints, and response fields differ by route. MiniMax’s official CLI repository generates video through the MiniMax API from the terminal (mmx video generate) and is a first-party reference for the async video flow. Community SDKs and example repos also surface under “hailuo-02” or “minimax” searches; verify the endpoint and response contract against the provider’s own docs before wiring one into production.

Provider details and pricing reflect public information as of August 7, 2026 and change frequently. Validate against each provider’s live pricing before committing. Access image and video models, including the leading Chinese models, through a single API key at www.modellix.ai.

Cover image: illustrative Modellix artwork; it is not a MiniMax product screenshot or source evidence.