MiniMax released the H3-Image weights on Nov 10, 2026: a 33.1-billion-parameter image model that generates and edits at up to 16 megapixels natively, in six sampling steps, and serves from a single GPU — the cheapest documented one-card route on our board is $1.69 an hour. The hard part is the licence, and it is not a footnote: the MiniMax-H3-Image Community License Agreement excludes the European Union, the United Kingdom, South Korea and the United States entirely, and requires MiniMax's prior written authorisation before anyone with over $1M in annualised revenue — or anyone offering the model as a hosted service — may use it at all. For most readers, the licence decides whether there is a deployment to price. This guide takes the decisions in the order they bind: licence first, memory second, rental third. The model facts come from MiniMax's own card, repo and LICENSE file, read Nov 13, 2026; the prices from our verified board, checked Nov 15, 2026.
What H3-Image is
From MiniMax's own card, read Nov 13, 2026: one checkpoint that unifies text-to-image generation and image editing — an edit is simply a request that carries reference images (up to 16). The diffusion transformer is a dense, single-stream design of 33.1 billion parameters in 50 layers; the weights are BF16, with the embedding, timestep and output layers in FP32. It generates about 16-megapixel images natively — 4096×4096 at 1:1, up to 6272×2688 at 21:9, a working range of roughly 4–20 MP — with no upscaler, distilled to 6 sampling steps with no classifier-free guidance. The text encoder is the full Qwen3-VL text encoder from the base MiniMax-H3, used unchanged — and, critically for the memory maths below, it is not counted in the 68.65 GB checkpoint figure. MiniMax names five serving frameworks on the card: SGLang, vLLM-Omni, diffusers, LightX2V and ComfyUI, with a one-GPU start command for the first two. An optional prompt-expander companion, MiniMax-H3-Image-PE (NVFP4, 17.9 GB), ships under the same licence. Full record: the model's catalogue entry on this site.
The licence is the first deployment decision
This is a community licence written by MiniMax (licensor: Nanonoble Pte. Ltd.; licence date Nov 10, 2026), not a permissive open-source licence. We read the LICENSE file in full on Nov 13, 2026. Four of its terms decide deployments before any GPU is rented, quoted in substance with their section numbers — read the file itself before you rely on any of this; we are a journal, not your lawyer.
| Term | What it says |
|---|
| The territory clause (Sections I.3, I.5, II, V.4) | Rights are granted “solely within the Applicable Territory” — worldwide excluding the “Excluded Territories”: the European Union, the United Kingdom, the Republic of Korea and the United States of America. Section V.4: you may not “use, reproduce, modify, distribute, or display” the model works or any of their Outputs outside that territory — “Any such use outside the Applicable Territory is not authorized by this Agreement.” Note the reach: not just where the GPU sits, but where the outputs are used. MiniMax says it keeps evaluating the excluded territories' laws and invites people there to contact it about a licence under “robust controls and guardrails” — a separate negotiation, not a download. |
| The authorisation clause (Section IV.1) | “You shall obtain a separate, prior written authorization from MiniMax” — via the form on its platform console — if the Annualized Revenue of you and/or your affiliates exceeds 1 Million USD, or you provide Hosted Service(s) to any Third Parties. Hosted service is defined broadly: the model's functionality made available to third parties via API, web access or any other remote means. In plain terms: a public image API or customer-facing generator on these weights needs MiniMax's written yes first, wherever you are — and so does any company over the $1M line, even for internal use. |
| The display and distribution duties (Sections IV.2, III) | A commercial product or service must “prominently display 'MiniMax-H3-Image'” on its user interface. Redistribute the weights and every recipient must get a copy of the agreement, modified files must carry prominent modification notices, and distributions outside a hosted service must include a NOTICE file with MiniMax's copyright line. |
| The output restriction (Sections V.3, I.11) | You may not use the model, “or any of their Outputs or results”, to improve any other artificial intelligence model (other than H3-Image or its derivatives). The definitions make a model distilled from H3-Image, or trained on its synthetic outputs, a Model Derivative — so that route inherits this licence whole rather than escaping it. MiniMax claims no rights over your outputs (Section VI.4); it restricts feeding them into another model's training. |
Three further terms belong in a deployment plan. Offer the model to the public and Section V.5 makes you operate safeguards, a violation-reporting mechanism and investigation/removal processes, with an Acceptable Use Policy (Exhibit A: 20 prohibitions, including undisclosed machine-generated content in public environments, impersonation without consent, and military use) incorporated by reference. Breach, and Section VIII.2 lets MiniMax terminate: you must stop, delete or destroy all copies, and notify downstream recipients. Disputes sit under Hong Kong law in Hong Kong courts (Section IX). All of it is decided before the rental — which is why this section comes before the prices.
The memory maths: 68.65 GB is not the model you run
The headline number on the card is the image checkpoint. The running stack is roughly twice it, because the text encoder is a separate component — loaded from the base MiniMax-H3 repository and not counted in that figure. From the card's own download table:
| Component | What it is | Size (card's download table) |
|---|
| transformer/ | The DiT: BF16 weights, embedding/timestep/output layers in FP32 | 66.28 GB |
| vae/ | The image VAE, FP32 | 2.34 GB |
| Heads, tokenizer, processor | Per-step output heads (12 MB) + Qwen3-VL tokenizer/processor (23 MB) | ~0.04 GB |
| Image checkpoint total | The card's Model Zoo figure for MiniMax-H3-Image | 68.65 GB |
| Text encoder | The full Qwen3-VL text encoder — not counted in the 68.65 GB figure; the pipelines load it from MiniMaxAI/MiniMax-H3, folder text_encoder/, per model_index.json and the card (“If you already have MiniMax-H3, it is not downloaded again”). The image repo also carries a bundled copy of the same folder | 66.7 GB |
| Full BF16 stack | What a serving process actually loads, before activations | ~135.35 GB |
The frameworks agree with the sum: SGLang's cookbook states that “downloading both checkpoints and the VAE requires about 135 GB”, and vLLM's recipe estimates full single-GPU residency at 135 GiB — weights plus the room a live process needs. (Units as each source prints them. The two sources also differ on disk: vLLM's own plan says “about 127 GB” — both figures stand as their sources print them.) The optional prompt expander adds 17.9 GB on top. Whoever budgets a 96GB card from the “68.65 GB” headline has under-budgeted by about 66.7 GB — the encoder is the trap in this release, and it is an arithmetic trap: the card's table is honest, the headline is just partial. There is no quantised checkpoint to rent down to. MiniMax's organisation publishes exactly three H3 repositories (checked Nov 13, 2026): the image model in BF16 only, the base H3, and the PE in NVFP4 — and the PE is a different, optional model, not a smaller H3-Image. What exists instead is framework-side quantisation: SGLang can quantise the DiT (optionally the encoder) to FP8/MXFP8 at load time from the BF16 checkpoint — its cookbook calls these “approximate modes” and warns that “quantization can change composition and reference identity”, which for an editing model is the product itself; vLLM-Omni's recipe states plainly that “quantization… [is] not qualified”. Treat load-time quantisation as an experiment you validate on your own reference images, never as the plan.
What the frameworks document, card by card
| Card class | Memory | What the frameworks document (Nov 13, 2026) |
|---|
| B300 / B200 | 288 GB / 192 GB | Full residency on one GPU — vLLM: the “natural choice” for its estimated 135 GiB; SGLang: 1 GPU, Auto resident. |
| H200 | 141 GB | The tested card. SGLang Auto keeps all components resident when ≥130 GiB is free at startup, “as tested on H200”; vLLM's profiles were measured on H200 — its one-GPU measured profile keeps the DiT resident and offloads the text encoder (73.4 GiB peak); full residency on H200 was estimated, not measured. |
| RTX PRO 6000 Blackwell | 96 GB | Named on MiniMax's card. SGLang publishes a measured one-card resident recipe using AdaLN precomputation (releasing about 24.6 GiB of projection weights); vLLM's one-GPU offload profile (73.4 GiB peak, measured on H200) also fits, and at two GPUs vLLM says every resident layout fits. The stack is managed, not simply resident — 135 GiB does not fit in 96 GB untouched. |
| H100 SXM / PCIe, H100 NVL | 80 GB / 94 GB | Residency is out — the stack exceeds the card by ~55 GB (80 GB) on weights arithmetic alone. Documented routes are offload routes: vLLM on 80GB H100 says “use DLO on one or two GPUs, or TP 4 on four (SP 4 does not fit)” — its full layer-offload profile peaks at 14.7 GiB, streaming layers from host RAM at native precision; SGLang's H100 row: “component offload on one; resident Ulysses2 with encoder fold on two”. |
| RTX 5090 / 4090 and other 12–48 GB cards | 24–48 GB | Layerwise offload only (SGLang's hardware table); vLLM documents a single RTX 4090 serving text-to-image under full offload, without qualifying the public image or 4090 throughput. A capacity experiment, not a serving plan. |
| AMD Instinct MI350X / MI325X | 288 GB / 256 GB | MiniMax's card lists the MI350X; vLLM verifies MI325X and MI350X on its ROCm image and SGLang ran measured resident recipes on both. Our board carries no AMD Instinct offers yet, so this guide prints no price for them — the route is real; the rental market for it is not yet on our board. |
Card memory figures are the board's own. Offload profiles stream weights between host RAM and GPU continuously: budget a host with fast local NVMe and plenty of RAM (SGLang's offload recipes assume a 256 GB-class host) — the GPU rate is not the whole machine bill on those routes.
The configs, priced
One GPU, rented by the card, on-demand, Nov 13, 2026. These are the routes the two sections above leave standing:
| Route | Card and shape | Rate (Nov 13, 2026) | Per day |
|---|
| RTX PRO 6000 Blackwell — RunPod Community | 96 GB, one card; measured SGLang resident recipe (AdaLN precompute) or vLLM encoder-offload profile | $1.69/GPU/hr | $40.56 |
| H200 — RunPod Community | 141 GB, one card; the frameworks' tested configuration | $3.59/GPU/hr | $86.16 |
| H200 — Hyperstack | 141 GB, one card | $3.99/GPU/hr | $95.76 |
| B200 — RunPod Community | 192 GB, one card; full residency, nothing offloaded | $5.98/GPU/hr | $143.52 |
| B300 — Hyperstack | 288 GB, one card; full residency with the most headroom on the board | $7.40/GPU/hr | $177.60 |
| H100 PCIe — RunPod Community (offload route) | 80 GB, one card; layer/component offload per the framework recipes — native precision, streamed weights | $1.99/GPU/hr | $47.76 |
| RTX 5090 — RunPod Community (capacity experiment) | 32 GB, one card; layerwise offload of everything — documented by SGLang's table, unmeasured as a service | $0.69/GPU/hr | $16.56 |
The same cards at other verified one-card rates, all checked Nov 13, 2026: RTX PRO 6000 — Nebius $1.80/GPU/hr (excludes VAT, as Nebius states) and RunPod Secure $2.69; H200 — RunPod Secure $5.29 and Nebius $5.40 (excl. VAT); B200 — Hyperstack $6.00; H100 SXM — RunPod Community $2.69 (offload route, as above). The rates that are not one-card routes. Some familiar names quote this class of card only inside whole machines: CoreWeave's H200 ($6.31/GPU/hr) is an 8-GPU node at $50.44 an hour, Oracle OCI's H200 ($10.00) an 8-GPU node at $80.00, Azure's ($10.60) an 8-GPU VM at $84.80 — real capacity, priced as nodes, and no use as a one-GPU door; TensorDock's H100 SXM rate ($2.25) carries an 8-GPU minimum, an $18.00/hr floor. Compare totals with totals. And one exclusion, stated plainly: a marketplace lists a PRO 6000 Max-Q at $0.75 on our board as a carried figure with no live listing behind it on our last check — carried, unverified figures do not price guides, so it appears nowhere above.
The serving route, as documented
The card's quick starts are one-GPU commands. vLLM-Omni: vllm serve MiniMaxAI/MiniMax-H3-Image --omni; SGLang: sglang serve --model-path MiniMaxAI/MiniMax-H3-Image (add --text-encoder-path if your encoder copy is local rather than in the Hugging Face cache). Both frameworks publish per-hardware recipes the card links to — SGLang's picker marks unmeasured combinations “unverified”, and its measured set covers H200/B300, AMD Instinct, one-card RTX PRO 6000 and DGX Spark; vLLM's profiles are H200-measured with configuration guidance for the rest. For lower latency both offer sequence parallelism across GPUs (Ulysses), and vLLM-Omni also splits the text encoder tensor-parallel — capacity first, speed second.
| Point | What the documentation says |
|---|
| The request contract | Steps are fixed at 6 and guidance at 1 — other values are rejected; there is no negative prompt; one image per request; prompts are used as given, truncated at 4,096 tokens. |
| The small-request cost line | Outputs below the minimum generation area (default 2048×2048) are still generated on a canvas of at least 2048² and resized back, so a “small, cheap” 1024×1024 request costs a 2048² generation unless you deliberately lower min_generation_area per request — a cost line hiding in the API contract. |
| Prompt expansion is a separate step | MiniMax's API expands short prompts into the detailed descriptions this model expects (its H3-Image-Context-IR step); self-hosting that step means either their API anyway, or the local PE model — the extra 17.9 GB checkpoint above, under the same licence. |
What it costs over real stretches of time
Assumptions, stated plainly: on-demand rates checked Nov 13, 2026; one GPU; GPU-hours only — storage, downloads (budget ~135 GB), egress and, on offload routes, the host machine are excluded because they vary by provider and are not part of the card rate. We publish no throughput figures of our own for this model — the frameworks publish their own measured latencies in their recipes — so nothing here is priced per image; these are the costs of holding the card, which is the decision a renter actually signs.
| Stretch | PRO 6000 — RunPod Community ($1.69/hr) | H200 — RunPod Community ($3.59/hr) | B200 — RunPod Community ($5.98/hr) |
|---|
| 24 hours — an evaluation day | $40.56 | $86.16 | $143.52 |
| One week (168 hours) | $283.92 | $603.12 | $1,004.64 |
| Around the clock, a month (730 hours) | $1,233.70 | $2,620.70 | $4,365.40 |
The offload routes sit below these: an H100 PCIe held around the clock at $1.99/hr is $1,452.70 a month — cheaper than the H200, dearer than the PRO 6000, and slower per image by construction. Read the table's shape: a day of honest evaluation costs less than a team lunch; the bill only becomes a strategy when the card never sleeps — exactly the point at which the licence's hosted-service authorisation, not the hourly rate, becomes the binding constraint on what you may do with it.
Who should not self-host
Four readers should stop before the rental, each for a different reason:
| If this is you | The honest route |
|---|
| You are in the European Union, the United Kingdom, South Korea or the United States | Under this licence the conversation ends there, for the model and for its outputs; MiniMax's own route for you is to ask it for a separate licence. |
| Your plan is to improve a different model with these outputs | Section V.3 forbids using the model or its outputs to improve any other AI model (other than H3-Image or its derivatives), and a model distilled from H3-Image counts as a derivative under Section I.11 — it inherits this licence whole: territory, authorisation and all. |
| You are planning a public hosted service and have not yet applied | The authorisation in Section IV.1 is prior and written; renting first and applying later puts the launch on the wrong side of the agreement. |
| Your usage is a handful of images a week | The same weights sit behind MiniMax's own API and apps (Hailuo), and the rental floor — from $40.56 a day before storage and your own serving work — buys a great deal of API usage first. We hold no verified per-image API price as of Nov 13, 2026, so we print no break-even: price your expected volume against roughly $1,234 a month for an always-on PRO 6000 and notice how much generation it takes before renting wins. |
Watch-outs
| The trap | Why it costs you |
|---|
| The territory follows the outputs | Section V.4 covers the model's Outputs, not just the weights: serving from an in-territory GPU to users in an excluded one is not a workaround the agreement leaves open. Where your users are matters as much as where your GPU is. |
| The affiliates trap in Section IV.1 | The $1M line is the annualised revenue of you and/or your affiliates — a small subsidiary of a large group is over the line even if its own books are tiny. |
| The download is bigger than the headline | The image repo alone is ~204 GB if you clone everything, because it carries native and diffusers copies of the transformer and VAE, plus a bundled copy of the text encoder — pull only what your framework needs, or provision ~135 GB for the full working set. |
| Offload is a host bill too | The documented small-card routes stream weights from host RAM — SGLang's offload recipes assume a 256 GB-class host with local NVMe. A cheap GPU hour attached to an undersized host is not the documented recipe. |
| Quantisation changes the product | Load-time FP8/MXFP8 in SGLang is labelled approximate by its own cookbook, with composition and reference identity liable to change — for an editing model, validate on your own reference images before serving it to anyone. In vLLM-Omni it is not qualified at all. |
| Termination means deletion | Breach the terms and the licence can be terminated with a duty to delete or destroy all copies and notify downstream recipients (Section VIII.2). Keep your compliance record as carefully as your checkpoints. |
How we know
Model facts and licence terms read first-hand on Nov 13, 2026 from MiniMax's own sources: the Hugging Face card for MiniMaxAI/MiniMax-H3-Image (33.1B dense DiT, 50 layers; 16 MP native, 4096×4096 to 6272×2688, ~4–20 MP working range; 6 steps, no CFG; up to 16 reference images; Model Zoo: BF16, 68.65 GB; download table: transformer 66.28 GB, VAE 2.34 GB, heads 12 MB, tokenizer/processor 23 MB, text encoder 66.7 GB loaded from MiniMaxAI/MiniMax-H3; frameworks named: SGLang, vLLM-Omni, diffusers, LightX2V, ComfyUI; one-GPU start commands for SGLang and vLLM-Omni; H200, RTX PRO 6000 Blackwell and MI350X named in the vLLM-Omni note) and its repo file list (component sizes as summed from the repo itself, agreeing with the card's table; the repo also carries a bundled text_encoder/ copy of ~66.7 GB alongside its native and diffusers weight copies, which is how a full clone of that one repo runs to ~204 GB); the LICENSE file in full (MiniMax-H3-Image Community License Agreement, licensor Nanonoble Pte. Ltd., licence date Nov 10, 2026 — Section I.5 Excluded Territories: EU, UK, Republic of Korea, USA; Section II grant solely within the Applicable Territory, with MiniMax's invitation to excluded-territory parties to contact it about a licence; Section III distribution duties; Section IV.1 prior written authorisation above $1M annualised revenue or for Hosted Services, requested via platform.minimax.io/console/license; Section IV.2 UI display of “MiniMax-H3-Image” on commercial products; Section V.3 no improving another AI model with the Works or their Outputs, outside H3-Image and its Model Derivatives; Section V.4 no use of Works or Outputs outside the Applicable Territory; Section V.5 service safeguards; Section VI.4 MiniMax claims no rights over Outputs; Section VIII.2 termination with deletion; Section IX Hong Kong law; Exhibit A Acceptable Use Policy, revised Nov 10, 2026); the vLLM recipe the card links to (component table: DiT 33.1B BF16, Qwen3-VL text encoder 33.4B BF16, VAE 0.58B FP32; disk plan ~127 GB; one-GPU profiles measured on H200: DiT resident + encoder offloaded 73.4 GiB peak, full layer offload 14.7 GiB peak; full residency estimated 135 GiB, “natural choice on B200 and B300”; on 80GB H100 “use DLO on one or two GPUs, or TP 4 on four”; on 96GB PRO 6000 every resident layout fits at two GPUs, SP 2 at 68.1 GiB/GPU; quantisation not qualified; MI325X and MI350X verified on the ROCm image, MI300X/MI355X not measured); and the SGLang cookbook the card links to (“downloading both checkpoints and the VAE requires about 135 GB”; Auto resident when ≥130 GiB free at startup, tested on H200, B300, MI325X, MI350X; hardware table: B200/GB200/GB300 1 GPU resident; H100/H800 80GB component offload on one, resident on two; RTX PRO 6000 Blackwell 96GB measured one-card resident recipe with AdaLN precomputation releasing ~24.6 GiB; 12–48 GB cards layerwise offload; online FP8/MXFP8 labelled approximate, quality/identity may change; offload recipes assume a 256 GB-class host). Prices are GPUJournal's verified board, checked Nov 13, 2026 on providers' own pages and banked the same day (87 priced offers): RTX PRO 6000 — RunPod Community $1.69, Nebius $1.80 excluding VAT, RunPod Secure $2.69; H200 — RunPod Community $3.59, Hyperstack $3.99, RunPod Secure $5.29, Nebius $5.40 excluding VAT; B200 — RunPod Community $5.98, Hyperstack $6.00; B300 — Hyperstack $7.40; H100 PCIe — RunPod Community $1.99; H100 SXM — RunPod Community $2.69; RTX 5090 — RunPod Community $0.69; all per GPU per hour, on-demand. Card memory figures are the board's own (PRO 6000 96GB, H200 141GB, B200 192GB, B300 288GB, H100 80GB, RTX 5090 32GB). Node and VM divisions are flagged wherever they appear (CoreWeave 8-GPU nodes, Oracle OCI nodes, Azure VMs; TensorDock's 8-GPU minimum). Three honesty notes: no per-image API price for this model exists in our checked records as of Nov 13, 2026, so this guide prints no API break-even; our board carries no AMD Instinct offers, so the MI350X route the maker documents is described but unpriced; and one marketplace PRO 6000 Max-Q figure ($0.75) sits on our board as carried and not re-verified, with no live listing behind it at last check — it is excluded from every table above. Live board: Compare prices. The model: MiniMax H3-Image in our catalogue. The release: MiniMax open-sources H3-Image.