MiniMax H3 ComfyUI workflow templates

The six official templates

The prefix says where the job runs and the suffix says what you feed it. A video_ file loads weights on your own machine; an api_ file sends the job to the hosted service. Then t2v starts from a prompt alone, i2v from one starting image, flf2v from a first and a last image, and r2v from reference media.

The two families are not mirror images, and the gap decides where some jobs can run at all. There is no video_minimax_h3_flf2v.json and no api_minimax_h3_i2v.json in the official set: first-and-last-frame exists only on the hosted side, the single starting image only on the local side. Text to video and reference media are the two tasks with a file on each side. That is a statement about which files ship, not about what each node will accept.

Source: Comfy-Org workflow templates. Checked 2026-08-13.

Download the three local JSON files

These copies all come from one pinned Comfy-Org revision, so the file this page describes is the file its button returns. The visible upstream names stay unchanged; the local download name adds the short commit so an update cannot silently overwrite a known graph.

Two of the three graphs open with sample media this site does not redistribute. The I2V file selects transparent_rgb_gaming_mouse.png; the R2V file selects red_superboy_on_city_roof.png and mecha_dragon_lightning.png. None of those images ships with the download, so replace every LoadImage selection with a local image you are allowed to use before queuing. The R2V default prompt also carries <Audio 1> while no reference-audio slot is connected: either connect a permitted reference audio file and keep that tag, or delete the tag. The generated output-audio path is separate from a reference-audio input.

Source and license: Comfy-Org/workflow_templates@7837633a31c1aa40495ed7f9171e9c97358a1d93, fetched and hash-checked 2026-08-21. The templates are MIT-licensed; the copyright and permission notice travels beside them in LICENSE.txt. The JSON files and license text are intentionally excluded from the sitemap.

Which template to start with

• Choose T2V when you only have a prompt.
• Choose I2V when one image needs to control the composition or subject.
• Choose R2V when you need a reference person, action, shot or sound.
• Choose the api_ series when you do not have a 12GB+ graphics card.

Two of those choices carry a download decision with them. T2V and I2V read the same diffusion model, so whichever of the two you try first, the other one costs nothing more to add. R2V reads a different one, and that stays a second large download whenever you get to it. If you are still deciding what you want to make, start on the shared side and leave the reference workflow for a later session.

The hosted row is a different decision rather than a smaller version of the same one. It removes the weights, the disk footprint and the memory ceiling, and puts an account, a key and a per-job charge in their place. Nothing measured on this page applies to it.

How T2V, I2V and R2V differ inside the JSON

The three local files are not three unrelated pipelines. At the pinned revision, T2V and I2V wrap the same collapsed Image to Video (MiniMax H3) subgraph. T2V leaves both frame inputs empty; I2V adds one LoadImage link to first_frame. R2V is the separate graph: it exposes its reference slots, prompt, sampler and decode chain directly on the canvas and loads Ref2VA instead of FL2VA.

The node IDs above are coordinates for revision 7837633a31c1…, not permanent API names. If a newer template moves them, follow the node types and links rather than assuming an old ID still points to the same control.

Pinned files checked 2026-08-21: T2V — 42,197 bytes, SHA-256 31ab33fd…1786e6; I2V — 44,684 bytes, bb71aecd…73009; R2V — 27,576 bytes, 099d24ed…029ffb. The repository is MIT licensed.

The defaults the graph actually sends

Read connected inputs before reading the number painted on a node. ComfyUI may retain a widget value even when an incoming link supplies the value that reaches the sampler. The table below records the controls and links in the pinned JSON, not recommended settings for every machine.

The duration conversion is stored in both graph families as:

max(5, round(a * 24)) + (5 - (max(5, round(a * 24)) % 17)) % 17

That expression snaps the requested duration to the model's 17k + 5 frame grid. At 24 fps, entering 5 seconds produces 124 frames and a nominal 5.1667-second clip. The same linked-control rule explains the other common surprise: in the two 16:9 files, a connected 0.4 MP selector produces 864 × 480 even though the generator node still caches 1344 × 768. This site's derived 1344 × 768 local ComfyUI API-format workflows bypassed those selector links and fixed the dimensions directly; they are not the untouched template defaults or the hosted api_ series.

What has to be on disk first

ComfyUI/
└── models/
    ├── diffusion_models/
    │   ├── minimax_h3_fl2va_pruned_int8_convrot.safetensors   # loaded by T2V and I2V
    │   └── minimax_h3_ref2va_pruned_int8_convrot.safetensors  # loaded by R2V only
    ├── text_encoders/
    │   └── qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors       # loaded by all three
    └── vae/
        ├── minimax_h3_video_vae_fp16.safetensors              # loaded by all three
        └── minimax_h3_audio_vae_fp32.safetensors              # loaded by all three

Only the diffusion model changes between tasks. The Qwen3-VL text encoder and both VAE files are read by all three local templates, so moving from one task to another does not fetch them again. That makes the install a two-step decision instead of one large commitment: the four-file set is approximately 42.47GB in decimal units and covers T2V and I2V, and adding the Ref2VA checkpoint brings a full local install to approximately 63.44GB. Both figures describe storage footprint, not minimum VRAM or system RAM requirements.

All three local templates reach the encoder through the same CLIP Loader node, and each needs its type switched to minimax or the encoder will not load. The templates require ComfyUI 0.30.0 or newer. Putting each file in the right folder, and what to do when a loader dropdown comes up empty, is covered on the MiniMax H3 ComfyUI workflow setup guide rather than repeated here.

File names, sizes and folder layout: ComfyUI MiniMax H3 tutorial; Comfy-Org MiniMax-H3 repository for the file index. Both checked 2026-08-13.

Fix the wiring stage before tuning memory

A smaller canvas is useful for a fast installation check, but it was not a low-memory mode on this site's RTX 3060 bench. Diagnose import, loader and input-link failures first; only then change memory settings, one variable per saved JSON copy.

This hub stops at cross-template mapping. The ComfyUI setup guide walks through the collapsed loaders, and the reference-task test card and its hardware incident are recorded in the run ledger.

What the three local templates cost on one 12GB card

Conditions for every figure in this table: physical GPU 0 was an RTX 3060 12GB; Proxmox VE VM 100 had 16 vCPU, 47.05 GiB RAM and no swap; ComfyUI 0.31.0 used PyTorch 2.13.0+cu130. Each row used a local ComfyUI API-format workflow derived from its pinned Comfy-Org template, with 1344×768, 124 frames, 24 fps, 20 steps, res_multistep / simple and a fixed seed. Derived workflow SHA-256: T2V 1b083dfa…545a2; I2V 22648d0a…30e40; R2V f52a1b91…257790. Turbo LoRA and SageAttention were enabled in none of them. The T2V and I2V rows were measured 2026-08-20 with native audio on; the R2V row was measured 2026-08-13 with audio off. Every row is two independent runs published as raw values, and no figure on this page is an average.

These three rows are not a controlled comparison. They were taken seven days apart, the audio track was on for two of them and off for the third, and the prompt, the input and the execution graph differ between the tasks. The gap between two rows is therefore not the price of the extra input — it is the gap between two separate test cards that happen to share a card and a canvas size.

What the rows do agree on is the shape of the constraint. Every run peaked between 10,863 MiB and 11,649 MiB against the 12,288 MiB the card has, so none of the three left much headroom, and all six finished between 36 and 43 minutes. System memory peaked between 43,587 MiB and 43,910 MiB in every case, which on most machines is the tighter of the two limits.

The T2V row has its own test card: T2V owns the canvas-cost facet. The complete chronological records for all three rows remain in the run ledger. The VRAM page explains what the headroom figures do and do not predict.

The R2V row is also the site's clean baseline: acceleration was switched off on purpose so later tests would have something to measure against. Eight cache nodes measured against that baseline cut a run to between 1.3× and 1.9× faster on the same card, though none of them reduces peak VRAM.

What the api_ series changes

The three api_ templates carry API nodes where the local ones carry loaders. Nothing in the tree above applies to them: no diffusion model, no encoder and no VAE is read from disk, so the 42.47GB footprint and the memory ceiling both stop being your problem. A MiniMax account, an API key and whatever the service charges per job take their place.

This site has not run the hosted templates. That is why the table above has three rows instead of six, and why this page offers no latency, price or quality comparison between the two paths. Such a comparison would have to borrow its numbers from elsewhere, and a borrowed number arrives without the conditions that give it meaning.

The templates ship with ComfyUI, not with the model

These six files are not part of MiniMax H3 itself. They live in the Comfy-Org workflow_templates repository and travel with the ComfyUI front end, which means the set can change under you when the front end updates. On 2026-08-13 that repository held 590 .json templates, 56 of them carrying the video_ prefix. The count came from the GitHub Git Trees API at repos/Comfy-Org/workflow_templates/git/trees/main?recursive=1, which answered truncated: false — the listing was complete rather than cut off at the API limit.

Two consequences are worth planning around. A template that gains or loses a node in a later release is a different graph under the same file name, so once a run succeeds, the copy you save from your own canvas is the more stable artifact to keep. And every figure in the table above was produced on ComfyUI 0.31.0; the templates name 0.30.0 as their floor, but nothing here has been re-measured on a newer front end.

Frequently asked questions

How many official MiniMax H3 workflow templates are there?

Six. Three run the model on your own GPU: video_minimax_h3_t2v.json, video_minimax_h3_i2v.json and video_minimax_h3_r2v.json. Three call the hosted API through API nodes: api_minimax_h3_t2v.json, api_minimax_h3_flf2v.json and api_minimax_h3_r2v.json.

What is the difference between the video_ and api_ MiniMax H3 templates?

The video_ templates load MiniMax H3 weights on your own machine and need roughly 42GB of model files on disk. The api_ templates send the job to the hosted MiniMax API and need an API key instead of local weights.

Which MiniMax H3 template needs the Ref2VA weights?

Only video_minimax_h3_r2v.json. Ref2VA is a separate download of about 20.97GB and it is the one file that is not shared. FL2VA covers both of the other local templates, and the Qwen3-VL encoder and the two VAE files are read by all three.

Is there a local first-and-last-frame MiniMax H3 template?

Not in the official set. First-and-last-frame ships only as api_minimax_h3_flf2v.json, which runs on the hosted service. The local files cover text to video, single starting image to video, and reference media to video.

How long do the local MiniMax H3 templates take on a 12GB card?

On this site's test machine, an RTX 3060 12GB, two runs of each template at 1344x768 and 124 frames took 2,175.5 and 2,176.2 seconds for T2V, 2,373.7 and 2,378.1 seconds for I2V, and 2,581.8 and 2,579.8 seconds for R2V. The R2V pair ran with audio off and seven days earlier, so the three tasks are not a controlled comparison.