Felo API PlatformFelo API Platform
Back to models

MiniMax H3 Image API

MiniMax-H3-Image is a text- and image-input image generation model that produces 16-megapixel images and supports multi-reference editing with up to 16 images.

MiniMax-H3-Image is an image generation and editing model from MiniMax. It accepts text and image inputs and returns images, generating at 4096 by 4096 pixels (16 megapixels). Text-to-image generation and multi-reference image editing are both supported, with up to 16 reference images in a single editing request. The model's documentation states the strongest instruction following among open-source models, and H3-Image-Context-IR can expand short prompts written in other languages into detailed English descriptions.

Generation runs on fixed inference settings: num_inference_steps 6 and guidance_scale 1. Prompts are truncated to 4096 tokens. Requested sizes below the minimum are generated on a larger canvas at the same aspect ratio and resized with LANCZOS interpolation; min_generation_area ranges from 1024 to 16777216 pixels, with a default of 4194304 (2048 by 2048). For reproducible seeds, the generator device is recommended to be set to CPU, and response_format should be set to b64_json.

It is suited to creative and commercial visual work, including advertising and branding, e-commerce, product design, UI/UX, gaming, concept art, product exploration, layout iterations, and focused edits that keep parts of the frame consistent. Strengths include 16-megapixel output at practical computational cost, rich detail and lifelike realism, and strong creative control through multi-reference images. Negative prompts are not supported and are rejected, and commercial use requiring separate written authorization must be requested through the platform.

Updated:

MODEL ID

minimax-h3-image
Input
text / image
Output
image

Highlights

  • 16-megapixel 4096 by 4096 output
  • Up to 16 reference images for editing
  • Fixed 6 inference steps and guidance 1
  • Documented top instruction following among open-source models
  • H3-Image-Context-IR multilingual prompt expansion
  • MiniMax-H3-Image Community License

Providers

1 providers

Compare API prices across providers. Select a provider to view all charges and conditions.

Provider · Pricing details
Uptime

Quick Start

Submit an image task, poll its status, then save the images. These examples use curl and Python 3 (standard library only).

POST https://openapi.felo.ai/api/v1/images/generations

1Get your API key

Create a key from your Felo API Platform account and set it as an environment variable.

export FELO_API_KEY="YOUR_API_KEY"

2Make your first request

Optional values vary by model. This example leaves them unset; confirm supported values in Playground before adding them. Request fields sit alongside model and prompt, without an input wrapper.

curl --fail-with-body --max-time 60 "https://openapi.felo.ai/api/v1/images/generations" \
  -H "Authorization: Bearer $FELO_API_KEY" \
  -H "Content-Type: application/json" \
  -o created.json \
  -d '{
  "prompt": "A studio product photo of a ceramic coffee cup on warm linen, soft morning light",
  "model": "minimax-h3-image"
}'

3Poll the task

Submission returns task_id. Poll every 3 seconds while queued or running; stop on succeeded, failed or interrupted. This example stops waiting after 30 minutes. Keep created.json to resume querying the same task instead of submitting again.

python3 - <<'PY'
import json, os, time
from pathlib import Path
from urllib.parse import quote
from urllib.request import Request, urlopen

task = json.loads(Path("created.json").read_text())
task_id = task["task_id"]
url = "https://openapi.felo.ai/api/v1/images/generations/" + quote(task_id, safe="")
headers = {"Authorization": "Bearer " + os.environ["FELO_API_KEY"]}
deadline = time.monotonic() + 1800

while task["status"] in ("queued", "running"):
    if time.monotonic() >= deadline:
        raise TimeoutError(f"Keep task_id={task_id} to resume polling")
    time.sleep(3)
    with urlopen(Request(url, headers=headers), timeout=60) as response:
        task = json.load(response)
    if task.get("task_id") != task_id or task.get("kind") != "image":
        raise ValueError("Unexpected task response")
    print(task["status"])

if task["status"] != "succeeded":
    raise RuntimeError(task.get("error") or task["status"])
if not task.get("outputs"):
    raise ValueError("Task succeeded without image outputs")
Path("task.json").write_text(json.dumps(task))
print("Saved task.json")
PY

4Download the output

After success, save outputs from task.json. Results may be HTTPS URLs, URL objects or b64_json. Download signed URLs promptly; media downloads do not use your API key.

python3 - <<'PY'
import base64, json
from pathlib import Path
from urllib.request import urlopen

task = json.loads(Path("task.json").read_text())
if task.get("status") != "succeeded" or not task.get("outputs"):
    raise ValueError("No completed image outputs")
extensions = {"image/png": ".png", "image/jpeg": ".jpg", "image/webp": ".webp", "image/gif": ".gif", "image/avif": ".avif"}

for index, output in enumerate(task["outputs"], 1):
    item = output if isinstance(output, dict) else {}
    url = output if isinstance(output, str) else item.get("url") or item.get("unsigned_url")
    mime = item.get("media_type") or "image/png"
    if url and url.startswith("https://"):
        with urlopen(url, timeout=60) as response:
            data = response.read()
            mime = response.headers.get_content_type()
    elif url and url.startswith("data:image/") and ";base64," in url:
        header, encoded = url.split(",", 1)
        mime = header[5:].split(";", 1)[0]
        data = base64.b64decode(encoded, validate=True)
    elif item.get("b64_json"):
        data = base64.b64decode(item["b64_json"], validate=True)
    else:
        raise ValueError("Unrecognized image output")
    path = Path(f"image-{index}" + extensions.get(mime, ".bin"))
    path.write_bytes(data)
    print(path)
PY
input_references

For image editing, replace the example URL with your HTTPS image URL or a base64 image data URL. Submit once, then use the same polling and saving steps.

curl --fail-with-body --max-time 60 "https://openapi.felo.ai/api/v1/images/generations" \
  -H "Authorization: Bearer $FELO_API_KEY" \
  -H "Content-Type: application/json" \
  -o created.json \
  -d '{
  "prompt": "Keep the product and framing. Replace the background with a sunlit marble countertop.",
  "model": "minimax-h3-image",
  "input_references": [
    {
      "type": "image_url",
      "image_url": {
        "url": "https://example.com/product.png"
      }
    }
  ]
}'

Supported parameters

  • n
  • size
  • resolution
  • aspect_ratio
  • output_format
  • input_references

Prefer the full reference?

API reference →

Frequently asked questions

What is MiniMax H3 Image?

MiniMax-H3-Image is an image generation and editing model from MiniMax. It accepts text and image inputs and returns images, generating at 4096 by 4096 pixels (16 megapixels). Text-to-image generation and multi-reference image editing are both supported, with up to 16 reference images in a single editing request. The model's documentation states the strongest instruction following among open-source models, and H3-Image-Context-IR can expand short prompts written in other languages into detailed English descriptions. Generation runs on fixed inference settings: num_inference_steps 6 and guidance_scale 1. Prompts are truncated to 4096 tokens. Requested sizes below the minimum are generated on a larger canvas at the same aspect ratio and resized with LANCZOS interpolation; min_generation_area ranges from 1024 to 16777216 pixels, with a default of 4194304 (2048 by 2048). For reproducible seeds, the generator device is recommended to be set to CPU, and response_format should be set to b64_json. It is suited to creative and commercial visual work, including advertising and branding, e-commerce, product design, UI/UX, gaming, concept art, product exploration, layout iterations, and focused edits that keep parts of the frame consistent. Strengths include 16-megapixel output at practical computational cost, rich detail and lifelike realism, and strong creative control through multi-reference images. Negative prompts are not supported and are rejected, and commercial use requiring separate written authorization must be requested through the platform.

How is usage billed?

Your bill depends on the provider you use, its prices and your usage. Longer inputs or other conditions may have different prices. Billed based on the actual generation cost. See your bill for the final amount.

What inputs does MiniMax-H3-Image accept?

It accepts text and image inputs and returns images. This covers both text-to-image generation and multi-reference image editing.

How many reference images can it use for editing?

Image editing supports up to 16 reference images. This makes it possible to keep parts of the frame consistent across focused edits.

What resolution does it produce?

It generates images at 4096 by 4096 pixels (16 megapixels). min_generation_area ranges from 1024 to 16777216 pixels, defaulting to 4194304 (2048 by 2048).

Can I change the inference steps or guidance scale?

No. The settings are fixed at num_inference_steps 6 and guidance_scale 1. Values other than the fixed ones return an HTTP 400 error.

Are negative prompts supported?

Negative prompts are not supported and are rejected. Prompts are also truncated to 4096 tokens.

How does it differ from MiniMax-H3-Image-PE?

MiniMax-H3-Image-PE is a locally deployable variant that can be run with a local SGLang server. MiniMax-H3-Image is the main image model in this family.

Related models