MiniMax Hailuo API: MiniMax 02, 2.3, and 2.3 Fast on Unifically (2026)

MiniMax Hailuo is MiniMax's second-generation video line. On Unifically it comes as three heads under the hailuo/minimax-* namespace: minimax-2.0 (the base "MiniMax 02"), minimax-2.3 (auto-routing text or image), and minimax-2.3-fast (image-to-video with lower latency). They share one async API surface but each has its own constraints, so picking the right head matters. This post walks through every head with the actual parameters from the Unifically docs.

TL;DR: Use hailuo/minimax-2.0 when you need start- and end-frame interpolation (only head that supports end_image_url). Use hailuo/minimax-2.3 as the default when the same call has to handle either text or image input. Use hailuo/minimax-2.3-fast when you already have a start image and want faster turnaround. All three accept 768p (default) or 1080p, and 6s (default) or 10s. 1080p is 6s only on every head.

What MiniMax Hailuo is

MiniMax Hailuo is MiniMax's second-generation video model line. Each head accepts a prompt (up to 2,000 characters) and/or a starting image, and returns an MP4 of either 6 or 10 seconds at 768p or 1080p. Generation is asynchronous: you POST to /v1/tasks and poll the same endpoint by task id until the video is ready.

The model line is built around three heads, each with a different sweet spot. The rest of this post goes head-by-head, then covers shared limits, pricing, code, and the gotchas worth knowing before you go live.

The three heads at a glance

Head	Identifier	Default mode	What it adds
MiniMax 02	hailuo/minimax-2.0	T2V or I2V	end_image_url for start-and-end-frame interpolation
MiniMax 2.3	hailuo/minimax-2.3	Auto-selects T2V or I2V	Stronger prompt adherence; one head for both modes
MiniMax 2.3 Fast	hailuo/minimax-2.3-fast	I2V only	Faster image-to-video; start_image_url is required

All three share the same resolution and duration grid (768p / 1080p, 6s / 10s, with 1080p capped at 6s) and the same prompt_optimization flag for letting MiniMax rewrite the instruction before generation.

MiniMax 02 (hailuo/minimax-2.0)

minimax-2.0 is the "MiniMax 02" base head and the reason most teams pick this line. It's the only head that accepts an end_image_url, which makes it the production choice for start-and-end-frame interpolation: upload an opening frame, an end frame, and a prompt, and the model animates between the two. That removes a manual cleanup pass for ad cutdowns, product spins, and any sequence where the open and close frames are non-negotiable.

Parameters per the Unifically docs:

Parameter	Type	Required	Notes
prompt	string	Conditional	Up to 2,000 chars. Required if no start_image_url
start_image_url	string	Conditional	Required if no prompt. Auto-uploaded
end_image_url	string	No	Closing frame to interpolate toward. 768p or 1080p only
duration	integer	No	6 (default) or 10. 1080p is 6 only
resolution	string	No	"768p" (default) or "1080p"
prompt_optimization	boolean	No	Let MiniMax rewrite the prompt before generation

You can run minimax-2.0 as text-to-video (prompt only), image-to-video (start image only), text + image, or text + start + end. The end-frame mode is the headline feature and the one that sets MiniMax 02 apart from most other video APIs at this price point.

MiniMax 2.3 (hailuo/minimax-2.3)

minimax-2.3 is the auto-routing default. The same model identifier handles T2V-2.3 when you send only a prompt, and I2V-2.3 when you also send a start_image_url. The benefit is one model id in your code path: the same call shape works whether the request is prompt-only or image-led, which keeps higher-level pipelines simple.

Parameters:

Parameter	Type	Required	Notes
prompt	string	Conditional	Up to 2,000 chars. Required if no start_image_url
start_image_url	string	Conditional	Required if no prompt. Auto-uploaded
duration	integer	No	6 (default) or 10. 1080p is 6 only
resolution	string	No	"768p" (default) or "1080p"
prompt_optimization	boolean	No	Let MiniMax rewrite the prompt before generation

There is no end_image_url on 2.3. If you need start- and end-frame interpolation, fall back to minimax-2.0. Pick 2.3 when prompt adherence matters more than frame-mode interpolation, or when your pipeline routes both prompt-only and image-led requests through one model id.

MiniMax 2.3 Fast (hailuo/minimax-2.3-fast)

minimax-2.3-fast is the image-to-video fast path. start_image_url is required, and prompt is optional. Use it for batched image-led pipelines (product photo to motion clip, character pose to short loop, that kind of thing) where writing a unique prompt per asset is overkill.

Parameters:

Parameter	Type	Required	Notes
prompt	string	No	Up to 2,000 chars. Optional even though it's accepted
start_image_url	string	Yes	Auto-uploaded
duration	integer	No	6 (default) or 10. 1080p is 6 only
resolution	string	No	"768p" (default) or "1080p"
prompt_optimization	boolean	No	Let MiniMax rewrite the prompt before generation

There is no end_image_url on 2.3 Fast either. The whole point of this head is to turn a start image into video as quickly as possible.

Shared limits

Across all three heads:

Head	6s duration	10s duration
hailuo/minimax-2.0	768p, 1080p	768p only
hailuo/minimax-2.3	768p, 1080p	768p only
hailuo/minimax-2.3-fast	768p, 1080p	768p only

In other words, if you ask for 1080p, the only legal duration is 6 seconds. For 10-second clips you have to drop to 768p. There is no 512p option in the current Hailuo API.

Pricing

Each head has its own line item under the hailuo/minimax-* namespace on the Unifically pricing page. Prices change as the upstream provider rates change, so the right move is to read the live rate before scaling a workload. Check the pricing page for the current per-second rate of each variant. The rate-card values are what bills against each generation, regardless of which playground tab you used.

How to call the Hailuo API

The API is async. POST a generation to /v1/tasks, then poll /v1/tasks/{task_id} until status === "completed". Inputs go inside an input object; the model id sits at the top level.

MiniMax 02 with start and end frame

const API = 'https://api.unifically.com';
const headers = {
  Authorization: `Bearer ${process.env.UNIFICALLY_API_KEY}`,
  'Content-Type': 'application/json',
};

const start = await fetch(`${API}/v1/tasks`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    model: 'hailuo/minimax-2.0',
    input: {
      prompt: 'Studio shot of a sneaker rotating on a marble plinth, soft rim light, slow camera dolly',
      start_image_url: 'https://example.com/sneaker-front.jpg',
      end_image_url: 'https://example.com/sneaker-back.jpg',
      duration: 6,
      resolution: '1080p',
    },
  }),
}).then((r) => r.json());

while (true) {
  await new Promise((r) => setTimeout(r, 3000));
  const task = await fetch(`${API}/v1/tasks/${start.data.task_id}`, { headers }).then((r) => r.json());
  if (task.data.status === 'completed') {
    console.log(task.data.video_url);
    break;
  }
  if (task.data.status === 'failed') throw new Error(task.data.error);
}

MiniMax 2.3 (text-to-video)

const start = await fetch(`${API}/v1/tasks`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    model: 'hailuo/minimax-2.3',
    input: {
      prompt: 'Wide shot of waves breaking on a black sand beach at dawn, slow motion',
      duration: 10,
      resolution: '768p',
    },
  }),
}).then((r) => r.json());

Send a start_image_url on the same model id and 2.3 routes to its image-to-video pathway automatically.

MiniMax 2.3 Fast (image-to-video, no prompt)

const start = await fetch(`${API}/v1/tasks`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    model: 'hailuo/minimax-2.3-fast',
    input: {
      start_image_url: 'https://example.com/product.jpg',
      duration: 6,
      resolution: '1080p',
    },
  }),
}).then((r) => r.json());

The polling loop is the same /v1/tasks/{task_id} call for every head, and for every Unifically model.

Things to know

• Asking for 1080p at 10 seconds. Not supported on any head. Drop to 768p for 10-second clips.
• Sending end_image_url to 2.3 or 2.3 Fast. Start-and-end-frame interpolation is minimax-2.0 only. The 2.3 line ignores or rejects the field.
• Calling 2.3 Fast without start_image_url. It's image-to-video only. The request fails without a start image.
• Calling 2.0 or 2.3 with neither prompt nor start_image_url. At least one of the two is required. Only 2.3 Fast tolerates an empty prompt.
• Hitting the wrong endpoint. All Unifically generations go through POST /v1/tasks with model at the top level and inputs nested under input. There is no per-model /minimax-hailuo/generate route.
• Mixing variant pricing. Each hailuo/minimax-* key prices independently. Sanity-check the pricing page before scaling, especially when toggling between 2.0 and 2.3 Fast.

Frequently asked questions

What is MiniMax Hailuo?

MiniMax Hailuo is a video model line that generates 6- or 10-second MP4 clips at 768p or 1080p. It's exposed on Unifically as three heads (hailuo/minimax-2.0, hailuo/minimax-2.3, and hailuo/minimax-2.3-fast) that share one async API surface.

Which Hailuo head should I pick?

Pick minimax-2.0 for start-and-end-frame interpolation. Pick minimax-2.3 as the default when the same call has to handle prompt-only and image-led inputs. Pick minimax-2.3-fast for image-to-video where you already have the start frame and want lower latency.

What's the difference between MiniMax 02 (2.0) and MiniMax 2.3?

minimax-2.0 is the only head that supports end_image_url, which is the headline feature for ad cutdowns and product spins. minimax-2.3 drops the end-frame option but auto-routes between text-to-video and image-to-video on a single model id and is tuned for stronger prompt adherence.

What durations and resolutions does the Hailuo API support?

6 or 10 seconds, at 768p (default) or 1080p. 1080p is 6 seconds only on every head. There is no 512p option in the current API.

Does the Hailuo API generate audio?

No. The Hailuo generate call returns silent video. Pair the output with a separate audio model (Suno, ElevenLabs) when you need a soundtrack.

How do I poll a Hailuo task?

GET /v1/tasks/{task_id} with your API key. The response carries status (pending, running, completed, failed) and the resulting video_url once it's completed. Polling is identical for every Unifically model.

Related reading

• MiniMax Hailuo model page: live playground with all three heads.
• Veo 3.1: another video API with native audio and 4K preview.
• Kling 2.6: another option with optional audio and 1:1 aspect ratio.
• Veo 3.1 vs SeeDance 2.0: head-to-head video API comparison.