MiniMax H3 Is Open-Sourced, But Not Fully: Which Parts of the 3 Modules Are Actually Released?

Author’s note: MiniMax has released the weights for both H3 and H3-Image, but the system components, cloud services, and community licenses define the limits of development and commercial use. This article breaks it down module by module and license by license.

On November 10, 2026, MiniMax released the model weights for H3-Image. Before that, on August 3, 2026, the omni-modal video generation model MiniMax H3 was open-sourced. The two releases came more than three months apart, and people often lump them together, but they’re two separate models with two separate licenses.

This isn’t an article about “fake open source.” The official announcements, the Hugging Face model cards, and the license texts all make it clear: what MiniMax has opened up is the weights and inference materials centered on the core generation model, not the entire cloud-side system. What we’re going to do here is sort out, item by item, what’s been released, what hasn’t, and how you can use it.

Key takeaway: By the end of this article, you’ll be able to tell the open status of each of MiniMax H3’s three modules, know which H3-Image components you can run locally, and understand the specific differences between the two Community Licenses on revenue thresholds and hosted services.

MiniMax H3 Open-Source Core Facts at a Glance

Let’s start by putting the timeline and basic facts in one table. Everything below is based on the official announcements, model cards, and the original license text, and was verified as of November 11, 2026.

6 MiniMax H3 Terms to Know Before You Read On

• Open weights: You’re allowed to get the trained model parameters, but what you can do with them is set by the license. It doesn’t mean the training data or the full pipeline is public.
• Community License: A usage license the model provider writes for itself. It isn’t a general-purpose open-source license like MIT or Apache 2.0.
• Checkpoint: A parameter file used to load a model. A single model can ship multiple checkpoints for different tasks.
• Context-IR: An official service that handles understanding of multimodal inputs, instruction parsing, and context organization. It’s currently offered as an API.
• Hosted service: Offering a model’s capabilities to third parties over a network, for example by exposing an API. This is the key scenario the license restricts.
• Sparse attention: A technique that computes only some of the attention relationships to cut the compute cost of long sequences.

MiniMax H3 Video Model: Only 1 of 3 Modules Is Open

The official announcement splits the full MiniMax H3 system into three modules. Understanding this split is the key to understanding why it’s “open source, but not fully open.”

The Two H3-Base Checkpoints

H3-Base isn’t a single weight file. It ships as two task-specific checkpoints. FL2VA covers text-to-video, first-frame-to-video, last-frame-to-video, and first-and-last-frame-to-video. Ref2VA can take images, video, and audio as references at the same time, which lets it handle more complex generation and editing tasks, such as keeping the original video’s characters and scenes while changing only the motion, lip movements, and dialogue.

Both checkpoints include the processor, tokenizer, text encoder, transformer, visual VAE, and audio VAE. In other words, what’s released is a model repository that can actually run inference, not bare weights that you have to fill in the missing pieces for yourself. That’s more complete than many “weights only” releases.

Local 768p vs. the Full 2K Workflow

Per the official specs, H3 outputs at 768px on the short side by default, with video lengths of 4–15 seconds, 24 FPS, and 32kHz stereo audio. If you deploy only the open-source H3-Base, you can generate 768p audio and video locally. To reproduce the official 2K output, you’ll also need to call the Context-IR and Regenerate-2K APIs.

So the more accurate way to put it: H3-Base can run on its own, but the complete H3 system can’t fully break away from MiniMax’s services. In a local setup, you’ll have to design the input understanding and instruction organization step yourself. Don’t assume there’s a local version of Context-IR.

The Easily Overlooked Sparse Attention

When the model was first open-sourced, the official team stated clearly that H3 natively supports sparse attention for both training and inference, which reduces the cost of long-sequence multimodal computation. However, the inference code in the initial release includes only Full Attention. The Sparse Attention implementation will be released separately in a later update.

That means open weights don’t imply that every internal inference optimization is open too. If you run long-video inference with the currently released code, the compute cost may be higher than what the official cloud service actually delivers. Keep that in mind as a variable when you evaluate performance.

Which Components Does MiniMax H3-Image Open Up?

H3-Image is released in much the same way as H3: the core model is available to download, but context processing still depends on the cloud. The table below is compiled from the Hugging Face model repositories.

Why the Text Encoder Comes from the H3 Repo

H3-Image reuses H3’s Qwen3-VL text encoder. The weights live in the H3 repo rather than being duplicated in the H3-Image repo. So to deploy H3-Image, you need to download both repos: the main model plus the text encoder add up to about 135.35 GB of storage. That’s just file size, and it isn’t the same as VRAM requirements.

The officially recommended deployment frameworks include SGLang, vLLM-Omni, Diffusers, and ComfyUI. The listed hardware includes NVIDIA H200, RTX PRO 6000 Blackwell, and AMD Instinct MI350X, and multi-GPU parallel setups are also supported. For most individual developers, that’s a pretty high hardware bar.

Context-IR and PE Aren’t the Same Thing

H3-Image-Context-IR is the official cloud service. It expands a short instruction into a full generation description and picks an appropriate image size. H3-Image-PE, on the other hand, is a prompt enhancement model you can download separately and run locally. It’s the official local alternative.

Just because PE is open doesn’t mean Context-IR’s multi-stage hosted workflow is open too. If you download only the image model and PE, you’ll get a usable local pipeline, but it won’t fully reproduce the official cloud results.

Keep Vendor Claims and Framework Tests Separate

“4K images in under 10 seconds” and “up to 16 reference images” come from the official model card and announcement, so they’re vendor claims. The vLLM deployment recipe, meanwhile, lists a maximum of 9 reference images, so the two figures aren’t measured the same way. How many reference images you can actually use depends on your inference framework and configuration, so base your evaluation on your own testing.

What Do MiniMax H3’s Two Licenses Actually Restrict?

This is the part of the two releases that’s easiest to get wrong. H3 and H3-Image ship under two different Community Licenses with noticeably different commercial terms, so you can’t apply one conclusion to both.

📌 Note: The above is a summary of the license terms, not legal advice. For the details of the territorial restrictions and other obligations, refer to the original text of both LICENSE files. If you just want to evaluate how generative and conversational models perform before committing, you can use APIYI (apiyi.com)’s unified interface to call mainstream models and compare options, then decide whether local deployment and an authorization request are worth the investment.

H3’s Boundaries: Commercial Use Is Allowed, but With Obligations

Within the permitted territories, H3 comes with a royalty-free limited license that allows commercial use. There are really only two hurdles: you need written authorization if annual revenue exceeds $20 million, and if you offer the model as a service to third parties, you must put safety measures in place and pass the usage restrictions on to your downstream users.

H3-Image’s Boundaries: Hosted Services Are a Hard Gate

H3-Image’s terms are much stricter. The annualized revenue threshold drops to $1 million, and if you offer hosted services to any third party, you need prior written authorization no matter how much revenue you have. The license also gives you a channel to contact MiniMax and request a separate license.

For API platforms, model hosting platforms, and SaaS developers, this means “the weights are downloadable” doesn’t imply “you can deploy them and open up a public API.” How strict this boundary is differs a lot between H3 and H3-Image.

Impact Analysis: What MiniMax H3’s Open-Source Release Means for Developers

When you look at how open each module is alongside the license terms, the freedom developers actually get varies a lot depending on the scenario.

The Real Freedoms Openness Gives You

The freedom that comes with open weights is real. Developers can deploy offline, keep data inside their own network, study the structure of a 33B-scale omni-modal model, and swap out or rework the pre- and post-processing steps in their local pipelines. Both models ship with complete inference components, which lowers the bar for community reproduction.

The Three Layers of Boundaries That Remain

The first layer is the system boundary: Context-IR and Regenerate-2K aren’t part of the open release. The second is the implementation boundary: H3’s Sparse Attention code wasn’t included in the initial release. The third is the license boundary: regional, revenue, hosting-service, and branding clauses together determine whether you can use the models commercially.

So open weights and cloud APIs end up coexisting. GPU procurement, inference optimization, high-concurrency scheduling, prompt enhancement, and compliance review don’t go away just because the weights are public. For many teams, a safer approach is to validate the business need first through an aggregation platform like APIYI (apiyi.com), then decide whether self-hosting is worth it.

Pre-Processing Example for the Local MiniMax H3 Workflow

Since Context-IR isn’t open, you’ll need to handle the input-preparation step yourself when running H3-Base locally. A common approach is to use a general-purpose Large Language Model to expand a short idea into a structured description, then hand that off to the local model. Keep in mind this is just an engineering workaround, and the results won’t match the official Context-IR.

Minimal Example

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "把简短视频创意扩写为详细镜头描述，包含主体、动作、镜头、光线和声音。"},
        {"role": "user", "content": "雨夜街头，一只猫跳上霓虹灯招牌"}
    ]
)
print(resp.choices[0].message.content)

import json
import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

SYSTEM_PROMPT = """你是视频生成提示词工程师。
请把用户的简短创意扩写为 JSON，字段包括：
- prompt: 详细的画面与动作描述
- camera: 镜头运动
- audio: 环境声与音乐描述
- duration: 视频时长（秒，取值 4 到 15）
只输出 JSON。"""

def build_context(idea: str, model: str = "gpt-4o-mini") -> dict:
    """Use a general-purpose Large Language Model to prepare the input, as a pre-processing step for the local H3-Base"""
    resp = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": idea},
        ],
        response_format={"type": "json_object"},
    )
    ctx = json.loads(resp.choices[0].message.content)
    # Clamp the duration to 4-15 seconds per the official H3 spec
    ctx["duration"] = max(4, min(15, int(ctx.get("duration", 5))))
    return ctx

if __name__ == "__main__":
    ctx = build_context("雨夜街头，一只猫跳上霓虹灯招牌")
    print(json.dumps(ctx, ensure_ascii=False, indent=2))
    # Next step: pass ctx to your local H3-Base inference workflow
    # (see the FL2VA inference example in the official GitHub repo)

🚀 Quick Start: If your local VRAM isn’t enough, you can grab free test credits at APIYI (apiyi.com) and get the prompt-preparation step running first. The platform offers an OpenAI-compatible interface, so a single API key lets you switch between models and compare which one works best for the pre-expansion step.

MiniMax H3 Open-Source FAQ

MiniMax H3 Open Source: Key Takeaways

• Only one of three modules is open: H3-Base is released, while Context-IR and Regenerate-2K remain official APIs.
• Complete checkpoints: Both FL2VA and Ref2VA ship with the tokenizer, VAE, and other inference components.
• Local runs top out at 768p: The full 2K video workflow depends on the official cloud service.
• Sparse attention is still to come: The first open-source inference code only includes Full Attention.
• The two licenses differ: H3 has a $20 million threshold, while H3-Image has a $1 million threshold.
• Hosted services are the red line: Offering H3-Image as a hosted service to third parties requires prior written authorization.
• Validate before you self-host: You can use the unified API from APIYI (apiyi.com) to check your business needs at low cost.

Summary

Here’s what matters about the MiniMax H3 release:

1. The core generation models are open: You can download and deploy the H3-Base and H3-Image main models, and the inference components are all there.
2. Cloud services are still part of the system: Context-IR and Regenerate-2K set the ceiling for what the full pipeline can do.
3. Licenses define your commercial boundaries: The two Community Licenses have different conditions, and H3-Image is clearly stricter about hosted services.

To judge how open a model really is, don’t stop at whether you can download the weights. Look at four dimensions: components, inference code, supporting services, and license. MiniMax has been genuinely generous with this release, but before you deploy or commercialize anything, check each of those four layers carefully.

If you’re evaluating image or video generation options, we’d suggest starting with the free credits on APIYI (apiyi.com) to quickly test your business workflow. Then decide whether local deployment and a license application are worth the investment.

📚 References

1. MiniMax H3 Official Open-Source Announcement: Three-module breakdown and Sparse Attention overview
2. Link: minimax.io/news/minimax-h3-open-source

3. Notes: A first-hand source for understanding the H3 system architecture and what’s been opened up

4. Hugging Face – MiniMax-H3 Model Repository: FL2VA and Ref2VA checkpoints and components

5. Link: huggingface.co/MiniMaxAI/MiniMax-H3

6. Notes: Includes the shared Qwen3-VL text encoder weights

7. MiniMax H3 Community License (Full Text)

8. Link: huggingface.co/MiniMaxAI/MiniMax-H3/blob/main/LICENSE

9. Notes: The authoritative source for the revenue threshold, geographic scope, and downstream obligations

10. Hugging Face – MiniMax-H3-Image Model Repository: Component list and deployment instructions

11. Link: huggingface.co/MiniMaxAI/MiniMax-H3-Image

12. Notes: The official model card, including vendor claims such as the reference image limit

13. MiniMax H3-Image Community License (Full Text)

14. Link: huggingface.co/MiniMaxAI/MiniMax-H3-Image/blob/main/LICENSE

15. Notes: Hosted service authorization and the $1 million threshold terms

16. vLLM Deployment Recipe – MiniMax-H3-Image

17. Link: recipes.vllm.ai/MiniMaxAI/MiniMax-H3-Image

18. Notes: Framework-side test configuration; its reference image limit differs from the model card

19. GitHub – MiniMax-H3 Source Code and Deployment Materials

20. Link: github.com/MiniMax-AI/MiniMax-H3
21. Notes: Local inference examples and deployment scripts

Author: APIYI Technical Team
Get in touch: Reach out to us through the APIYI website homepage. For more integration resources, visit the docs.apiyi.com documentation center.

Related Articles

• Before Using MiniMax H3 for Commercial Video Products: 5 Steps to Confirm Capabilities, Licensing, and Deployment Boundaries: A pre-launch checklist guide for video product teams on MiniMax H3, using five steps to confirm model capabilities, commercial licensing, deployment methods, and cost definitions, so as to avoid making technical decisions based on rumors.
• MiniMax H3-Image vs Seedream 5.5: How to Choose for 100 Rounds of Image Editing — Understand the 2 Models Through 5 Tables: MiniMax-H3-Image excels at roughly 16MP direct output and up to 16 reference images, while Seedream 5.5 excels at its officially self-reported roughly 100 rounds of continuous editing and native transparent backgrounds; this article gives a verdict on which to choose for which job, and explains which generation of Seedream APIYI can invoke today.
• Kimi K3.1 Pro Open Weights Explained: 2 License Conditions and a 1.56 TB Self-Deployment Threshold: Break down one by one the 2 commercial conditions of the Kimi K3.1 Pro open-weight license, give judgments for three scenarios—internal use, external API, and large-scale consumer products—and outline self-deployment thresholds such as 1.56 TB weights, MXFP4 precision, and inference frameworks.
• Kimi K3.1 Pro Officially Released: New Features, Pricing, and Availability at a Glance: Kimi K3.1 Pro officially launched on 2026-10-24 with a 1M context window and three unit prices 33% lower than K3; it is available on the web, app, Kimi Code, and API, with weights to be released before 2026-11-04, and this article summarizes its new features, five pricing tiers, and available channels.