MiniMax H3 Open Weights: Download & ComfyUI Guide

On 31 July 2026, MiniMax launched the H3 video model via API. Two days later they published the MiniMax H3 Community License. On 3 August, the weights landed on Hugging Face — 33 billion parameters, two checkpoints, and ComfyUI support the same day.

If you've been searching for "MiniMax H3 open source" or "MiniMax H3 download," here's what actually happened and what you can actually do with it.

The three-day timeline

The release was staggered, and each step changed what you could do with H3:

• 31 July 2026 — API launch. MiniMax opened the H3 API on platform.minimax.io. At this point, the only way to use H3 was through the API or browser-based tools that wrapped it. No weights, no local running.
• 2 August 2026 — Community License published. MiniMax released the license text that would govern the open-weights release. This is when the territory restrictions became public — before the weights were even available to download.
• 3 August 2026 — Open weights on Hugging Face. The 33B-parameter model appeared on Hugging Face under MiniMaxAI/MiniMax-H3, with a mirror on ModelScope. ComfyUI support from Comfy-Org launched the same day with quantized checkpoints and three workflow templates.

The gap between the license and the weights matters. It gave people a day to read the terms before the download links went live. Whether that was intentional or just logistics, it was the right order — several prominent community members flagged the territory exclusions during that window, which saved others from downloading hundreds of gigabytes they couldn't legally use.

This is open weights, not open source

You'll see plenty of posts calling MiniMax H3 "open source." It isn't, and the distinction matters if you're planning to deploy.

Open source means the code and weights are released under a license approved by the Open Source Initiative — anyone can use, modify, and redistribute with minimal restrictions. Think Apache 2.0 or MIT.

Open weights means the model weights are downloadable and you can run them locally, but the license has conditions. MiniMax H3 falls into this category.

The MiniMax H3 Community License allows free non-commercial use and commercial use for companies with annual revenue under $20 million USD. Modification and fine-tuning are permitted.

But it excludes four territories: the United States, the European Union, the United Kingdom, and South Korea. If you're in one of those places, you are not licensed to run the weights locally or distribute outputs generated locally.

The license doesn't explain why. It defines an "Applicable Territory" and those four aren't in it.

This is the single biggest thing most coverage gets wrong or skips entirely. Tutorials telling you how to run H3 locally rarely mention that doing so may not be licensed where you live. Read the license text yourself before deploying — this article is not legal advice.

The model: 33 billion MiniMax H3 parameters

MiniMax H3 is a 33B-parameter dense Transformer that generates synchronized video and audio in a single forward pass. Every specification below comes from either the official API documentation or the Hugging Face model card published by MiniMax:

The "dense" part matters. Some large models use mixture-of-experts (MoE) architectures where only a fraction of the parameters activate per token, so a "100B MoE model" might only use 30B parameters during inference. H3 is dense — all 33 billion parameters are active for every frame. That's why it needs significant GPU resources even when quantized.

The joint audio-video architecture is what sets H3 apart from most other video models. Instead of generating silent video and then running a separate audio model, H3 produces both modalities in a single forward pass. The video VAE handles visual frames while the audio VAE handles synchronized stereo audio — both decode from the same latent space. The result is lip sync, sound effects, and ambient audio that arrive aligned with the video, not dubbed on afterwards.

A few things worth calling out:

The 1440p figure is wrong. The official resolution tiers are 768P and 2K. The 1440p number appeared in early second-hand coverage and has been repeating ever since. It's not an official tier.

Duration starts at 4 seconds, not 5. Multiple competitor articles say 5–15 seconds. The API documentation says 4–15.

"Extendable to 30 seconds" is not an official claim. Some coverage states you can extend to 30 seconds. The model generates 4–15 second clips; anything longer is multiple generations edited together. MiniMax has not announced an extension feature for H3.

Where to download MiniMax H3: Hugging Face, ModelScope, and Comfy-Org

Three places to get the weights. Which one you pick depends on where you are and how you plan to use them.

Hugging Face (primary source)

The official repository is MiniMaxAI/MiniMax-H3 on Hugging Face. The total repository is approximately 498 GB at full precision — but you don't need all of it.

There are two task-specific checkpoints:

• FL2VA (First-and-Last-frame to Audio-Video): handles text-to-video and image-to-video, with optional first and last frame inputs
• Ref2VA (Reference to Audio-Video): handles multi-reference generation with up to 9 images, 3 video clips, and 3 audio clips simultaneously

Most people only need one. If you're doing text-to-video or image-to-video work, FL2VA is enough. If you need character consistency across shots using reference material, you want Ref2VA.

How to choose: if you have a script and want to generate footage from text descriptions or a single keyframe image, start with FL2VA. If you have a character photo and need that character to appear consistently across multiple shots — or you want to feed in a voice sample so the model matches it — Ref2VA is the one. You can download both, but each is a significant download on its own, so start with the one that matches your immediate workflow.

Download both checkpoints:

huggingface-cli download MiniMaxAI/MiniMax-H3 \
  --include "model_index.json" "FL2VA/*" "Ref2VA/*" \
  --local-dir MiniMax-H3

Download just FL2VA (text-to-video / image-to-video):

huggingface-cli download MiniMaxAI/MiniMax-H3 \
  --include "model_index.json" "FL2VA/*" \
  --local-dir MiniMax-H3

If you use Diffusers instead of ComfyUI, you can also load directly:

from diffusers import ModularPipeline
pipe = ModularPipeline.from_pretrained("MiniMaxAI/MiniMax-H3")

Tips for downloading large model files

The full-precision H3 repository is 498 GB. Even a single checkpoint is tens of gigabytes. A few practical notes:

• Use huggingface-cli rather than the browser. Browser downloads of multi-gigabyte files are unreliable. The CLI tool supports resumable downloads — if your connection drops, re-run the same command and it picks up where it left off.
• --include is your friend. The download command above uses --include to pull only the checkpoint folders you need. Without it, you'd download the entire 498 GB repo including both checkpoints at full precision plus documentation and assets.
• Check your disk space first. A full-precision single checkpoint can be over 100 GB. The quantized Comfy-Org versions are much smaller but still multi-gigabyte. Make sure your target drive has room before starting.
• If you're behind a corporate firewall or VPN, Hugging Face's large file downloads sometimes stall. Try downloading without the VPN, or use the ModelScope mirror if you're in Asia.

MiniMax H3 on ModelScope (mirror for China)

MiniMax maintains an organization page on ModelScope. If you're in China and Hugging Face is slow or blocked, this is the alternative. Same weights, same license, same file structure. ModelScope's CDN is optimized for Chinese networks, so download speeds will be significantly better than pulling from Hugging Face's servers.

Comfy-Org (quantized for ComfyUI)

If you're using ComfyUI, you typically don't download from the official repo directly. Comfy-Org hosts pre-quantized versions that are already optimized for the ComfyUI pipeline — smaller downloads, lower VRAM, ready to slot into the node graph:

The Comfy-Org versions use INT8 quantization for the diffusion models and NVF4+AWQ for the text encoder — dramatically smaller downloads and VRAM usage compared to full-precision weights from the official repo.

Setting up MiniMax H3 in ComfyUI

What you need before starting

• ComfyUI 0.30.0 or later — older versions don't have the H3 nodes. The MiniMax H3 support is built into ComfyUI from this version; no custom node packs to install.
• A GPU with sufficient VRAM — the official docs don't state a minimum. Community reports indicate the quantized Comfy-Org checkpoints run with around 12 GB of VRAM when using CPU offloading. More VRAM means faster generation and less swapping.
• Disk space for the quantized checkpoints — significantly less than the 498 GB full-precision repo, but still a multi-gigabyte download.

Step 1: Update ComfyUI

Make sure you're on 0.30.0+. If you're running an older version, pull the latest from the ComfyUI repository. The H3 nodes appear automatically — no extra installation.

Step 2: Get the models

ComfyUI's built-in model manager can pull the Comfy-Org quantized versions for you. Alternatively, download manually from Comfy-Org/MiniMax-H3 and place the files in the corresponding model directories.

Step 3: Load a workflow template

Three official workflow templates ship with H3:

1. Text-to-Video (T2V) — type a prompt, get a clip with synchronized audio
2. Image-to-Video (I2V) — provide a first frame, last frame, or both as image inputs
3. Reference-to-Video (R2V) — feed in reference images, video clips, and audio for character and style consistency

The template files are on GitHub:

• T2V workflow
• R2V workflow

Load one, connect your models, write a prompt, and generate.

Which template to start with depends on what you're making:

• T2V is the simplest — just a text prompt. Good for testing that your setup works and for generating footage from scratch. Start here if you're new to H3.
• I2V gives you more control. Supply a first frame (or first and last frame) and the model generates the motion between them. Useful for product shots where you want a specific starting composition, or for animation where you need a defined start and end pose.
• R2V is the most powerful but also the most demanding. You feed it reference images for character appearance, video clips for motion style, and audio clips for voice or atmosphere. This is how you get the same character across multiple shots — but it needs the Ref2VA checkpoint, and it's slower because it's processing more input data.

Step 4 (optional): Install Sage Attention

Sage Attention roughly doubles generation speed with minimal quality loss. It's a separate install — not bundled with ComfyUI by default. If generation time matters, it's worth the extra setup.

What to expect on consumer hardware

Be realistic: a 5-second clip at 768P takes several minutes on most consumer GPUs. This is a 33B-parameter model — even quantized, that's substantial compute per frame.

The main bottleneck is VRAM. When the model doesn't fit entirely in GPU memory, ComfyUI offloads parts to system RAM — the model still runs, but generation slows down significantly because data moves back and forth over the PCIe bus. A card with 24 GB of VRAM (RTX 4090, RTX 3090) will keep more of the model resident and generate noticeably faster than a 12 GB card that offloads heavily.

If speed matters more than local control, the API path may suit you better — a 5-second 768P clip through the API finishes in seconds rather than minutes, and costs about $0.40.

If you can't deploy locally

If you're in the US, EU, UK, or South Korea — or you don't have a GPU that can handle it — local deployment isn't a licensed or practical option. That doesn't lock you out of H3 entirely.

The official API bills per second of output and works regardless of location:

A 10-second 2K clip costs about $1.30. A 5-second 768P test costs about $0.40. Iterate at 768P, finalize at 2K — that pricing gap makes experimentation cheap.

Browser-based tools like this site run H3 through the API on your behalf. No setup, no GPU requirement, free credits on signup. To be clear: this is an independent third-party tool, not the official MiniMax platform. Credits here don't transfer to a MiniMax account.

Both the API and browser tools operate under MiniMax's service terms, which are separate from the weights license. They work everywhere.

The community ecosystem

In the days since the weights dropped, the Hugging Face community has been busy:

• 29 Spaces already run H3 demos you can try in the browser
• 19 fine-tuned variants have been published for specific domains
• 20 quantized versions are available — GGUF, INT4, INT8, various formats for different hardware
• 49 discussion threads in the model's community tab

The fine-tuned variants are worth watching. People are already adapting H3 for specific workflows — anime styles, product videos, talking heads with particular voice characteristics.

If you're considering a community quantization to squeeze into less VRAM, check what was tested. Some quantization methods degrade audio quality more than visual quality, and audio-visual sync is the thing that makes H3 different from other video models. A quantization that makes the video look fine but breaks the lip sync has missed the point.

The 20 quantized versions already cover a range of formats: GGUF for llama.cpp-compatible toolchains, INT4 for extreme compression, INT8 for a balance between quality and size. The Comfy-Org INT8 versions are the safest starting point — they're officially structured for ComfyUI and have been tested by the Comfy-Org team. Community quantizations may work well but carry more risk of subtle quality degradation, especially in audio fidelity.

What other coverage gets wrong

Since this article exists to give you verified first-party information, here's what most MiniMax H3 articles get wrong:

1. Calling it "open source" — it's open weights with a restrictive community license
2. Listing 1440p as a resolution tier — official tiers are 768P and 2K only
3. Saying the duration is 5–15 seconds — it's 4–15 seconds
4. Claiming "extendable to 30 seconds" — not an official feature
5. Omitting the territory restriction — the license excludes US, EU, UK, and South Korea from local deployment
6. Citing OpenArt or X posts as the data source — those are aggregators, not MiniMax. Specs should come from the official API docs and the Hugging Face model card

Every specification in this article is sourced from either platform.minimax.io or the official Hugging Face model card. Where an official number doesn't exist, we say so rather than guessing.

Frequently asked questions

Is MiniMax H3 free to download?

Free to download, yes. Free to use depends on where you are and what you're doing with it — check the license section above.

What's the minimum VRAM to run H3 locally?

MiniMax hasn't published an official minimum. Community reports indicate the Comfy-Org INT8 quantized checkpoints run with approximately 12 GB of VRAM when using CPU offloading. More VRAM means faster generation.

Is MiniMax H3 on ModelScope?

Yes. MiniMax has an organization page on ModelScope at modelscope.cn/organization/minimax. Same weights and license as the Hugging Face release.

Can I fine-tune MiniMax H3?

The license permits modification within the applicable territory. Nineteen fine-tuned variants already exist on Hugging Face as of this writing.

Why can't I run the weights locally in the US, EU, UK, or Korea?

The community license defines an "Applicable Territory" that excludes those regions. No reason is stated. This only affects running the weights on your own hardware — the API and browser-based tools work everywhere under separate service terms.

Is ComfyUI the only way to run it locally?

No. The model also supports Diffusers (ModularPipeline.from_pretrained()) for Python-based pipelines and SGLang for multi-GPU serving deployments. ComfyUI is the most accessible option if you want a visual workflow editor rather than writing code.

How does MiniMax H3 compare to running other video models locally?

At 33B parameters, H3 is significantly larger than most locally-runnable video models. The tradeoff is that it generates synchronized audio and video in a single pass — something most alternatives can't do at all, requiring separate audio generation and manual sync. If audio isn't part of your workflow, smaller models may be more practical for local use.

Do the community fine-tunes inherit the same license restrictions?

Yes. The MiniMax H3 Community License applies to derivative works, which includes fine-tuned variants. A fine-tune published on Hugging Face by a third party doesn't override the original license's territory restrictions or revenue cap.

What's the difference between the official Hugging Face repo and the Comfy-Org repo?

The official MiniMaxAI/MiniMax-H3 repo has full-precision weights suitable for Diffusers, SGLang, or custom pipelines. The Comfy-Org/MiniMax-H3 repo has quantized and pruned versions specifically structured for ComfyUI's model directories. If you're using ComfyUI, use the Comfy-Org repo. If you're writing your own inference code or using Diffusers, use the official repo.

Can I use H3 to generate content for commercial use?

Within the applicable territory and if your company's annual revenue is under $20 million USD, yes. Above that revenue threshold, or outside the applicable territory, you need a separate commercial agreement with MiniMax. Using H3 through the official API or browser-based tools is governed by MiniMax's service terms instead, which have their own commercial-use provisions.