MiniMax Next-Gen Model: Release & API Preview

If you want to test MiniMax Hailuo 2.3 today, here’s the short answer: it supports text-to-video and image-to-video on the Standard model, image-to-video only on Fast, and it outputs 6- or 10-second clips at 768p or 1080p. Pricing starts at about $0.28 per 6-second clip on Standard and $0.19 on Fast, with a simple submit → poll → download API flow.

If I strip it down to what matters most, this launch is about four things:

• What you can do now: text-to-video and image-to-video
• What it costs: about $0.0248 to $0.072 per second on APIMart, depending on model and resolution
• How to connect it: POST /video_generation, then check status with GET /query/video_generation
• Who it fits best: teams making short ads, product clips, explainers, and test variants

There are also some clear limits. Fast does not support text-to-video. Input images must be under 20 MB, have a short edge above 300 px, and stay within the allowed aspect-ratio range. Standard output usually takes about 30 to 90 seconds per clip, so this is better for short video jobs than long-form editing.

Minimax Hailuo API Tutorial: Clone Voice, AI Video & Music Generation + Make.com Automation

Quick Comparison

What stood out to me is this: the model is simple to try, pricing is easy to estimate, and the API is straightforward. So if you’re checking whether Hailuo 2.3 fits your workflow, the main question is not “Can I access it?” but “Do I want better output quality or lower cost per clip?”

2. What MiniMax Hailuo 2.3 Delivers at Launch

MiniMax Hailuo 2.3 is MiniMax’s short-form video model for cinematic clips. It’s built for fluid motion, expressive characters, and prompts that stick close to what you asked for.

2.1 Core capabilities and supported workflows

At the model level, the main choice is Standard vs. Fast.

Standard Hailuo 2.3 supports both text-to-video and image-to-video. It gives you better motion consistency, more lifelike output, and tighter style control. It also usually takes 30 to 90 seconds per clip.^[2][5][7]

Fast is image-to-video only. It leans into speed and lower cost, but you give up some image quality in return.^[3]

Playback lands around a cinematic 24 fps, but that should be treated as a general target, not a locked spec.^[3][7][8]

In practice, this choice affects three things right away:

• how long each clip can take
• how polished the output looks
• how fast a team can move from prompt to finished draft

2.2 Motion, character, and style improvements

The biggest step up from Hailuo 02 shows up in character movement and emotion.

Hailuo 2.3 uses facial muscle simulation to handle small expressions like eyebrow movement, shifts in eye focus, and subtle head tilts. It also uses Global Identity VAE to keep faces, hair, and clothing more stable from frame to frame.^[1][4][9]

Camera movement is stronger too. You can use bracketed commands like [Pan left], [Zoom in], and [Tracking shot], and the model supports up to three of these commands in one prompt. On top of that, Hailuo 2.3 adds more style control with rendering options for anime, ink-wash painting, and game-CG aesthetics.^[1][4][6][9]

That means teams can be more deliberate about how a clip feels. A character close-up, a slow push-in, or a stylized product shot is less of a guessing game and more of a prompt-writing task.

2.3 Where Hailuo 2.3 fits best

Hailuo 2.3 works best for short, punchy clips. If you need a longer piece, it makes more sense to generate the shots here and stitch them together in a standard editor.

Use Standard Hailuo 2.3 when output quality, style direction, and prompt detail matter most, like hero ads, trailers, or character-driven moments. Move to Fast when speed and volume matter more, especially for variation testing or batch social production.

Those launch-level differences carry straight into API setup, output constraints, and integration decisions in the next section.

3. API Preview: Endpoints, Inputs, Outputs, and Access

3.1 Request and response structure

Hailuo 2.3 follows a simple submit → poll → download flow. You send a POST /video_generation request, get back a task_id, and wait while the video is processed. After that, you poll for status. When the job finishes, the API returns a download link. These fields line up with the two launch paths: text-to-video and image-to-video.

For text-to-video, the request needs a prompt field. That prompt can be up to 2,000 characters long. For image-to-video, you also send first_frame_image as the reference image. The image can be passed as either a public URL or a Base64 string. Files must stay under 20 MB, the short edge must be above 300 px, and the aspect ratio must fall between 2:5 and 5:2.

The main controls are:

• duration for clip length, with common values of 6 or 10 seconds
• resolution set to "768P" or "1080P"
• prompt_optimizer as an optional flag

After submission, GET /query/video_generation returns a status like "processing", "success", or "failed". If the job succeeds, the response includes the video URL or file reference. If it fails, you get an error_code and error_message.

Polling every 15 to 30 seconds is a sensible rhythm. Hit it too often and you just create noise. One more thing: output links on APIMart stay live for 72 hours, so it makes sense to move finished files into your own storage soon after generation.

3.2 Direct access and APIMart unified API access

Teams can call MiniMax’s native endpoints directly with a Bearer token in the header:

Authorization: Bearer YOUR_API_KEY

This route keeps you closest to MiniMax’s own docs and release timing.

APIMart offers another path for teams that want one place to manage multi-modal work. Its unified API gives you one API key and one USD balance across text, image, and video calls. It also uses an OpenAI-compatible request style, which can make setup easier if your stack already speaks that format. If you're wiring several model types into one pipeline, that kind of setup can save time on the client side.

3.3 Pricing and billing in U.S. dollars

Pricing is charged per generated second in U.S. dollars. APIMart lists rates at about a 20% discount versus MiniMax’s official pricing.

A practical way to manage cost is to test at 768P and save 1080P for final renders. That keeps early iteration cheaper while still leaving room for higher-output delivery later.

4. Integration Patterns for Multi-Modal Workflows

4.1 Python SDK and REST Implementation Patterns

Once your request and response format is set, the next move is wiring Hailuo 2.3 into a pipeline you can run again and again. The simplest way to think about it: Hailuo 2.3 is the render layer inside a bigger system. Keep your API key in an environment variable, use Bearer auth on every request, and use requests for video generation calls while relying on SDKs for prompt orchestration.

import os
import time
import requests

API_KEY = os.environ["APIMART_API_KEY"]
BASE_URL = "https://api.apimart.ai/v1"

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

payload = {
    "model": "MiniMax-Hailuo-2.3",
    "prompt": "[Slow zoom in] A ceramic coffee mug on a sunlit kitchen counter, steam rising, photorealistic",
    "duration": 6,
    "resolution": "768P",
    "prompt_optimizer": True,
}

response = requests.post(f"{BASE_URL}/video_generation", json=payload, headers=headers)
task_id = response.json()["task_id"]

while True:
    status_resp = requests.get(
        f"{BASE_URL}/query/video_generation",
        params={"task_id": task_id},
        headers=headers,
    )
    result = status_resp.json()

    if result["status"] == "success":
        file_id = result.get("file_id")
        video_url = result.get("video_url")
        break
    if result["status"] == "failed":
        raise Exception(result.get("error_message", "Video generation failed"))

    time.sleep(20)

If polling feels clunky, add a callback_url and let the system notify you when the render is done. After that, pass the returned file_id or download URL into your storage or publishing step.

Once the API flow is in place, the next job is setting defaults that keep spend and output quality under control.

4.2 Pipeline Designs for Content and Product Teams

Most content and product teams can get by with three pipeline patterns. They line up with the article’s main use cases: text-to-video, image-to-video, and post-render audio assembly.^{[13][10][12][20][21]}

For an ad clip workflow (text → video), an LLM builds a structured prompt with a setting, subject, motion description, and bracketed camera direction. For example:

[Pan left] A pair of running shoes on a track, golden hour lighting, cinematic

That prompt is then sent into a Hailuo 2.3 text-to-video request. This setup works well for short 6-second clips.^[16]

For a product demo workflow (image → video), upload a clean product still and pass it as first_frame_image to Hailuo 2.3. That keeps the product visually accurate while adding motion a static image can’t show.^[13][10][12]

For a narration sync workflow (video + audio), render the video first. Then add voiceover or music in post using a speech or music model, and combine everything in your publishing pipeline.

If you need sequences longer than 10 seconds, chain clips together. Take the last frame from one generation and feed it into the next request as first_frame_image. It’s a simple handoff, but it helps keep character appearance and scene continuity steady across segments.^[10][12]

4.3 Parameters to Standardize Before Rollout

It helps to treat this as rollout policy. Locking a short list of defaults before scaling keeps output steady, cost easier to plan for, and team usage aligned.^{[16][17][18][19]}

A short checklist usually does the job:

• Prompt template - Use one shared structure: setting, subject, motion, camera direction, and style tag such as "cinematic", "product demo", or "user-generated feel". Keep a library of prompts that have already worked so teams reuse them instead of starting from zero.^[11][14][15]
• Duration - Match clip length to the job. Use 6-second clips for previews and social content. Save 10-second clips for campaigns that need the extra time.
• Resolution - Set 768P as the default for drafts and iteration. Use 1080P only for final renders.
• First-frame image rules - Spell out where approved source images live, make sure files stay under 20 MB with a short edge above 300 px, and define what counts as a strong reference frame for image-to-video work.^{[10][17][18][15]}
• Model selection - Use MiniMax-Hailuo-2.3-Fast for high-volume batch runs. Save MiniMax-Hailuo-2.3 (Standard) for higher-fidelity final output.^[19]

Those defaults shape the cost profile and model choice discussed next.

5. Cost, Model Selection, and Final Takeaways

5.1 Estimating Cost for Common U.S. Production Scenarios

Once your launch setup and API flow are in place, the next thing to nail down is production cost.

A 6-second 768p clip on Hailuo 2.3 costs about $0.29, and a 10-second clip costs about $0.49. On Hailuo 2.3 Fast, those same clips come in at about $0.15 and $0.25.

For a U.S. e-commerce brand making 80 standard 10-second product clips per month at 768p, the total generation cost is about $39.00.

A simple way to think about it:

• Use Hailuo 2.3 Fast for drafts, A/B variants, and batch testing
• Use Hailuo 2.3 for live product pages, paid social, and app store previews

Price matters, of course. But it shouldn't be the only thing driving the choice. What you need the output to do matters more.

5.2 Choosing MiniMax Hailuo 2.3 Inside APIMart's Catalog

The choice comes down to three things: final output quality, draft speed, or batch volume.

The nice part is that one integration covers both tiers. So if your team wants to switch from draft mode to final-output mode, you can do that without changing request logic.

5.3 Key Points to Carry Forward

If you're picking between the two tiers, the rule is pretty simple: Hailuo 2.3 is built for short-form video, especially brief clips where motion consistency and brand fit matter most.

Before you scale, run a tight pilot. Generate a controlled batch of clips at 6 seconds and 10 seconds. Then review motion quality and brand fit with your creative team, make sure turnaround time works for your production flow, and confirm that APIMart's billing view matches the seconds used and total cost in USD.

FAQs

Which model should I start with?

For most users, Hailuo 03 is the best place to start. It’s the newest model, and it works best for complex multimodal workflows like text-to-video, image-to-video, synced audio, and precise camera controls.

If you need stylized art, human motion, or micro-expressions, Hailuo 2.3 is a good pick. If your work leans more on physics-heavy motion and highly realistic movement, Hailuo 02 is also a solid choice.

You can access all of them through the unified APIMart API by setting the model parameter.

How can I make clips longer than 10 seconds?

For videos longer than 5 seconds, use a lower resolution like 768p or 512p. 1080p only supports clips up to 5 seconds, so it won’t work for longer outputs.

Need more than the API’s 10-second clip limit? Generate a few clips and stitch them together in your backend. It’s best to handle this asynchronously, either by polling the job status or by using a callback URL to get a completion notification.

What usually causes a generation request to fail?

A generation request can fail for a few common reasons:

• Invalid parameters
• Invalid API keys
• Insufficient account balance
• Rate limits (429)
• Internal server errors (5xx)

Image-based requests can also fail when the input files are larger than 20 MB or the aspect ratio falls outside 2:5 to 5:2.

If a task status changes to failed, check the error_message field for the exact reason.