MiniMax H3 ComfyUI reference to image: Consistent Character Workflow (Free JSON)

Keeping the same face across generated images can be frustrating. In this MiniMax H3 ComfyUI reference to image tutorial, I’ll show how I used a reference-to-video model to save a still portrait while preserving the reference identity.

The trick is simple: request the shortest sequence, decode it, and save its first frame. I tested this on my RTX 5080 with 16 GB VRAM, using no custom nodes. The fresh 1152×2048 close-up portrait below took 244.285 seconds at 20 steps. It retains a strong visual likeness to the reference while bringing the face much closer; fine facial details and background features are regenerated. I’ll show the actual input images, exact prompt, wiring, measured results and free workflow download. Earlier benchmark measurements are kept separately as historical results.

What is MiniMax H3 ref2va (and why use it for images)?

Reference-to-video + audio in one model

MiniMax H3 ref2va is a reference-to-video(+audio) model. Here, I’m using its reference conditioning for a still image. The workflow retains the model’s video and audio VAE inputs, even though the final output is a PNG.

This is useful when you want to experiment with a consistent face from a reference photo without adding a character LoRA. My test used no LoRA; it is a practical example, not a promise that every reference or prompt will behave identically.

The single-frame trick in one sentence

Set length = 5, decode, select frame 0 with ImageFromBatch, and save with SaveImage.

MiniMaxH3ReferenceToVideo: length = 5
VAEDecode → ImageFromBatch: batch_index = 0, length = 1 → SaveImage

Lengths follow the 17k + 5 grid at 24 fps, so the minimum request is 5, not 1. This is a minimum-length video request, followed by single-frame extraction. The core MiniMax H3 node source defines the length setting. The extraction node limits the saved output to one still.

Requirements

Tested setup (ComfyUI version, frontend, templates, PyTorch, GPU)

These are the versions and hardware I used:

GPU: NVIDIA RTX 5080, 16 GB VRAM
ComfyUI: 0.38.1
ComfyUI frontend: 1.53.6
Workflow templates: 0.11.73
PyTorch: 2.11 + cu130

Use the official ComfyUI repository and ComfyUI documentation for installation and update guidance appropriate to your setup.

VRAM and disk space

The fresh portrait run completed on a 16 GB RTX 5080. Its highest sampled total-device memory was 15,867 MiB (15.50 GiB), including desktop and other GPU usage; process-specific peak VRAM was not measured. Smaller cards were not tested. Earlier VRAM observations are listed separately in the results section. My recorded test-download estimate was about 40.5 GB; current repository file sizes may differ. Check your available storage before downloading.

No custom nodes needed

All nodes in this workflow are core ComfyUI nodes. The MiniMax H3 integration is in:

comfy_extras.nodes_minimax_h3

If the MiniMax node is missing, check your ComfyUI version before searching for a third-party node pack.

Download the MiniMax H3 models

Which file goes in which folder

Download the files from Comfy-Org/MiniMax-H3 on Hugging Face. Keep each filename unchanged so it matches the supplied workflow.

These are the approximate sizes recorded for my test; repository file sizes may differ. Check the model license, including territorial and commercial-use conditions, before use or distribution.

Once the downloads finish, refresh the model lists or restart ComfyUI. Check every loader before queueing; a missing file or the wrong subfolder can prevent the workflow from running.

Optional turbo LoRAs

Turbo LoRAs are optional and go in ComfyUI/models/loras/. I did not use them in this test or evaluate their still-image quality. Start with the settings below to reproduce my workflow before experimenting.

Start from the official template (video_minimax_h3_r2v)

Look for the MiniMax H3 reference-to-video template in ComfyUI’s template browser. Its file is:

video_minimax_h3_r2v.json

The official workflow-templates repository is the source to check if your installed templates do not show it. Keep a copy of the original video graph before adapting its output branch.

You can also use my download below. It is an API-format JSON export, so import behavior depends on your frontend. If your installation does not reconstruct it, build the graph from the wiring table rather than treating the file as a guaranteed visual-workflow import.

Build the MiniMax H3 ComfyUI reference to image workflow step by step

Step 1: Load the model, text encoder and both VAEs

Add UNETLoader, CLIPLoader, and two VAELoader nodes. Select the corresponding files from the models table. Use these loader settings:

UNETLoader: weight_dtype = default
CLIPLoader: type = minimax, device = default

Keep the video VAE and audio VAE separate. The reference node needs both; the image decoder later uses the video VAE.

Step 2: Load your reference images

Add two LoadImage nodes. Connect the identity photo first and the scene photo second:

LoadImage (identity) → ref_images.ref_image_0 → <Picture 1>
LoadImage (scene) → ref_images.ref_image_1 → <Picture 2>

The download uses sample filenames. Select your own images in both loaders; the JSON does not include the reference photos. Choose photos you have permission to use.

Step 3: Configure MiniMaxH3ReferenceToVideo

Connect the text encoder, video VAE, and audio VAE to their matching inputs. Set:

width = 1152
height = 2048
length = 5
ref_image_size = match

Width and height must be multiples of 32. I used match for reference-image sizing in this test. The node offers nine image slots, three reference-video slots, and reference-audio inputs; this example uses only the two image references.

Step 4: Sampler setup

Use BasicGuider, KSamplerSelect, BasicScheduler, RandomNoise, and SamplerCustomAdvanced. Connect the model to both the guider and scheduler.

The reference node’s conditioning output is slot 0; its latent output is slot 1. These go to the guider’s conditioning input and the sampler’s latent input respectively. Use the following complete wiring to check your graph.

Step 5: Decode and grab one frame with ImageFromBatch

Connect the sampler output to VAEDecode and use the video VAE. Send the decoded images into ImageFromBatch:

batch_index = 0
length = 1

Do not confuse this extraction length with the generation length. The reference node requests the minimum sequence; this node chooses the first decoded image.

Step 6: SaveImage instead of SaveVideo

Connect the extracted image to SaveImage. My downloadable graph uses:

filename_prefix = minimax_h3/ref2image

The still-image path ends here. The official video path instead uses audio decoding and video assembly through VAEDecodeAudio, CreateVideo, and SaveVideo.

Writing prompts with <Picture 1>, <Picture 2> tags

Tag order = connection order

Tags refer to the connected slots, not image filenames. State what each reference controls: identity, scene, or another visual feature. Reference videos and audio use <Video 1> and <Audio 1>.

Example prompt (copy-paste)

This is the exact prompt from my test:

Photorealistic very tight head-and-shoulders beauty portrait photograph. <Picture 1> defines the exact same adult woman's facial identity, facial proportions, brown eyes, nose, lips, wavy dark-brown hair, emerald gown and gold drop earrings. <Picture 2> supplies only the rooftop setting, warm golden-hour light and city skyline softly blurred behind her. The same glamorous fully clothed adult woman, approximately 30 years old, looks directly into the camera with a poised, confident expression. The camera is very close to her face. Her face dominates the composition, filling most of the image; her eyes, nose and mouth are large and clearly detailed. Frame tightly from the top of her head to her collarbone and upper chest only, with just the tops of her shoulders and the high emerald-green neckline visible along the bottom edge. Her head is almost frontal with a subtle natural turn. Crisp focus on both eyes with detailed brown irises, natural catchlights, individual eyelashes and eyebrow hairs. Realistic fine skin pores, subtle freckles, fine facial hairs, natural under-eye detail and softly textured lips, gentle natural makeup, no beauty smoothing or plastic skin. Wavy hair frames her face and a gold drop earring is clearly visible. Soft warm sunset rim light and gentle fill illuminate her face, flattering but realistic skin tones, shallow depth of field, 85mm portrait lens, refined editorial photography. The rooftop and domed city skyline form soft golden bokeh in the background. This is a close-up facial portrait with a tight head-and-shoulders crop: no full-body view, no waist shot, no distant figure.

Tips to get a new pose and scene

With ref_image_size = match, the model leans heavily on the reference layout and pose. To get a new scene, ask for a clearly different pose and setting and connect only the identity reference.

If you disconnect the scene reference, remove its tag and instructions from the prompt too. Describe the desired scene directly. The output is sensitive to prompt wording, so small changes can matter. Compare the composition as well as the face when reviewing results.

Recommended settings (cheat sheet table)

These are my tested settings, not a universal preset for every GPU or reference:

Results and performance on an RTX 5080 (16 GB)

Fresh detailed portrait test: 1152×2048

The detailed portrait shown here was newly generated with MiniMax H3 on 16 October 2026, using the two references above. It is not a crop or enlargement of another generated image. ComfyUI reported 244.285 seconds from execution start to success (about 244 s); observed request-to-completed-history time was 245.515 s. The run used 1152×2048, length = 5, ref_image_size = match, 20 steps, res_multistep + beta, and seed = 777, with no LoRA. I saved only frame 0.

The highest sampled total GPU-device memory was 15,867 MiB (15.50 GiB), from 303 nvidia-smi samples; the pre-run baseline was 925 MiB. This includes desktop and any other process usage on that GPU, and sampling can miss brief peaks. Process-specific and PyTorch allocator peak VRAM were not measured. This total-device figure is not directly comparable with the historical VRAM reports below.

The result shows strong visual similarity to the identity reference, with detailed brown irises, eyelashes, eyebrow hairs, skin texture, freckles and lips. Individual facial details and the expression are regenerated; I did not measure a biometric identity score or establish an exact identity match.

The framing is tighter than a conventional head-and-shoulders portrait: the top of the hair and most shoulders are cropped by the generated composition, while the emerald neckline remains visible. The earring is partly hidden. The rooftop becomes a narrow area of golden bokeh, so its specific dome and architecture are not reliably identifiable. This example prioritizes face detail over a recognizable scene.

Historical benchmarks from the previous example

These earlier measurements used different reference images and prompts. They are retained as historical observations and do not describe the woman’s portrait shown above:

• Earlier 1152×2048 test: ref_image_size = match, 20 steps, about 176 s, and previously reported 9–11 GB VRAM. That example preserved a close likeness but also copied the reference framing.
• Earlier 4K portrait test: 2144×3808, ref_image_size = max, 30 steps, about 375 s, and previously reported 13 GB peak VRAM. It also used length = 5 and saved frame 0 with ImageFromBatch.

No new 4K run was performed for the woman’s portrait. The historical memory reports were not established using the same total-device sampling method as the new run. These runs also vary in references, prompt, resolution, reference sizing or step count, so they do not isolate the speed or memory effect of any one setting. Treat all timings as observations from this setup, not guarantees for another machine.

Limitations you should know

1. Framing and scene obedience vary. My earlier test copied the reference layout with ref_image_size = match. The new close-up changes the framing substantially, but crops more tightly than requested and leaves the rooftop indistinct. Ask explicitly for the composition you need and review the actual output. Try only the identity reference when you want to describe a new scene directly.
2. Generation takes time. The current 1152×2048 portrait took 244.285 s at 20 steps on an RTX 5080. Historical runs took about 176 s and 375 s with their separately listed settings and references. These observations do not establish a speed comparison between reference-sizing modes.
3. Only tested on a 16 GB card. The fresh portrait’s sampled total-device peak was 15.50 GiB; process-specific peak VRAM was unmeasured. Historical reports of 9–11 GB and 13 GB used different runs and are not like-for-like memory comparisons. Smaller cards were not tested, so I cannot claim they work.
4. Big download. My approximate test-download estimate was 40.5 GB (21 + 15.7 + 3.2 + 0.6 GB); current repository file sizes may differ.
5. Sensitive to prompt wording. Small wording changes can change the result. Expect to iterate.
6. It’s a video model used for stills. One frame per run. Turbo LoRAs exist but were not tested for image quality in this guide.

Troubleshooting

• Node not found or red nodes: update ComfyUI to 0.38.1 or newer. The MiniMax H3 nodes are core in that version.
• Model missing from a loader: check the filename and correct models/ subfolder, then refresh or restart.
• Text encoder errors: confirm CLIPLoader has type = minimax.
• Video or multiple saved frames: check generation length = 5 and extraction batch_index = 0, length = 1. The final output node should be SaveImage.
• Resolution errors or odd crops: use width and height that are multiples of 32.
• Reference pose copied: change the pose/setting wording and use only the identity image.
• Too slow: timings apply only to each observed run. The current portrait and historical examples vary in prompt, references or settings, and I did not benchmark the optional turbo LoRAs, so I cannot promise a speedup or the same image quality.

Download the MiniMax H3 Reference-to-Image ComfyUI Workflow

Download the MiniMax H3 Reference-to-Image ComfyUI Workflow (.zip)

The ZIP contains MiniMax_H3_Reference_to_Image.json (a normal ComfyUI canvas workflow that you drag onto the canvas), the original API graph from the successful portrait run as MiniMax_H3_Reference_to_Image_api.json, the exact portrait prompt in prompt.txt, and a README. Only the two reference-image filenames and the output prefix were normalized for portability. Model filenames, prompt, settings and connections are preserved. The reference images are linked above and are not bundled in the ZIP.

WordPress does not accept the raw JSON upload, so the files come zipped. The canvas file was rebuilt from the API graph (same nodes, links and values), so no API-import support is needed in your frontend.

What is inside the zip:

• MiniMax_H3_Reference_to_Image.json: ComfyUI workflow in the normal canvas (UI) format. Drag it onto the canvas.
• MiniMax_H3_Reference_to_Image_api.json: the same graph in API format, for scripts or the /prompt endpoint.
• prompt.txt
• README.txt: model files with download links and folders, custom nodes and setup steps.

Requirements:

• No custom nodes: every node is part of ComfyUI core. Update ComfyUI to the latest version first.
• minimax_h3_audio_vae_fp32.safetensors in ComfyUI/models/vae/ (download)
• minimax_h3_ref2va_pruned_int8_convrot.safetensors in ComfyUI/models/diffusion_models/ (download)
• minimax_h3_video_vae_int8_convrot.safetensors in ComfyUI/models/vae/ (download)
• qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors in ComfyUI/models/text_encoders/ (download)

Model weights are not included. Every node and link in these files was checked against the current ComfyUI source and the node packs listed above.

1. Download the ZIP and extract MiniMax_H3_Reference_to_Image.json.
2. Drag the JSON onto the ComfyUI canvas (or use Workflow > Open).
3. Download the identity and rooftop reference PNGs above, or choose images you have permission to use. Upload/select them in the two LoadImage nodes: reference_identity.png is Picture 1, and reference_scene.png is Picture 2.
4. Check all model filenames, the prompt and settings, then press Queue. The portable output prefix is minimax_h3/ref2image.

The downloadable portrait PNG preserves the generated pixels and embeds portable prompt/workflow metadata. Private machine metadata was removed, and input/output filenames were normalized. Its reconstructed UI-workflow metadata was not separately round-tripped through the browser UI. After importing the API graph or reconstructing it manually, save a normal visual workflow in your own ComfyUI installation.

FAQ

Can MiniMax H3 generate still images in ComfyUI?

Yes. MiniMax H3 ref2va is a reference-to-video model. Set length to 5 for the minimum-length sequence, decode it, pick frame 0 with ImageFromBatch, and save it with SaveImage.

Do I need custom nodes for the MiniMax H3 workflow?

No. This workflow uses core ComfyUI nodes, including the MiniMax H3 integration from comfy_extras.nodes_minimax_h3. I tested on ComfyUI 0.38.1 with frontend 1.53.6.

How much VRAM does MiniMax H3 need for a 1152×2048 image?

The current detailed portrait completed on an RTX 5080 16 GB card, with a sampled total-device memory peak of 15,867 MiB (15.50 GiB). That includes other GPU usage; process-specific peak VRAM was not measured. The earlier 9–11 GB report belongs to a different historical test. Smaller cards were not tested.

How long does one image take?

The detailed portrait shown here took 244.285 seconds for one 1152×2048 saved frame at 20 steps on an RTX 5080 with ref_image_size set to match. The earlier 176-second result is a separate historical test, not the timing of this portrait.

How do I refer to my reference images in the prompt?

Use tags in the order the images are connected: <Picture 1> for ref_image_0, <Picture 2> for ref_image_1, and so on. Reference videos and audio use <Video 1> and <Audio 1>.

How many reference images can I use?

The MiniMaxH3ReferenceToVideo node has 9 image slots (ref_image_0 to ref_image_8), 3 reference video slots (0–2), plus reference audio inputs.

Why does my output copy the pose of the reference photo?

With ref_image_size = match the model leans heavily on the reference layout and pose. Ask for a clearly different pose and setting in the prompt, and use only the identity reference when you want a new scene.

What resolution should I use?

Width and height must be multiples of 32. I used 1152×2048 (portrait) with ref_image_size set to match.

Where do I download the MiniMax H3 models?

From the Comfy-Org/MiniMax-H3 repository on Hugging Face (https://huggingface.co/Comfy-Org/MiniMax-H3). File names and folders are listed in the models table above.

Can I make a video with the same workflow?

Yes. Raise length (lengths follow the 17k+5 grid at 24 fps, e.g. 5, 22, 39), then use the video-output branch from the official video_minimax_h3_r2v.json template instead of ImageFromBatch/SaveImage: decode the video with VAEDecode, decode audio with VAEDecodeAudio, combine them in CreateVideo, and save with SaveVideo.

Which model files does video_minimax_h3_r2v.json need?

The official template lists five files, all from Comfy-Org/MiniMax-H3 on Hugging Face: minimax_h3_ref2va_pruned_int8_convrot.safetensors (20.97 GB) in ComfyUI/models/diffusion_models/; qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors (15.69 GB) in ComfyUI/models/text_encoders/; minimax_h3_ref2v_turbo_4step_v0.1_comfyui_bf16.safetensors (1.96 GB) in ComfyUI/models/loras/; minimax_h3_video_vae_int8_convrot.safetensors (2.81 GB) in ComfyUI/models/vae/; minimax_h3_audio_vae_fp32.safetensors (605 MB) in ComfyUI/models/vae/. Sizes are from the Hugging Face file listing. No custom nodes are needed.

Conclusion

The MiniMax H3 ref2va single-frame trick gives me a practical way to turn reference photos into a still image using core ComfyUI nodes. Start with the tested setup, keep the extraction settings correct, and inspect both identity and composition before calling a result successful.

Try the free workflow and share your results or questions in the comments. Subscribe to Freakyjolly for more practical ComfyUI workflows.

For related workflows, see my local AI video models roundup.