Image 01 Image to Image | Fast Image Editing API

MiniMax Image-01 Image-to-Image

MiniMax Image-01 Image-to-Image is an advanced AI model that transforms existing images using text prompts. Part of the MiniMax image-01 family, this model enables you to generate variations, apply style transfers, modify compositions, and create character-consistent images from reference photos. Perfect for creative workflows, product visualization, and content creation.

Key Features

Image-Based Generation Generate new images based on an existing image input combined with text prompts. The model intelligently understands the reference image and applies your text description to create variations.
Character Reference Support Use portrait photos as character references to maintain consistent character appearance across generated images. Ideal for creating character variations, different poses, or placing characters in new scenes.
Flexible Image Dimensions Specify custom dimensions from 512×512 to 2048×2048 pixels (must be divisible by 8) for precise control over output size. Common sizes include 1024×1024, 1280×720, 1152×864, and more.
Prompt Optimization Built-in prompt optimizer automatically enhances your text descriptions for better generation results, helping you achieve the desired output even with simple prompts.
Batch Generation Generate up to 9 images in a single request, perfect for exploring variations and selecting the best result.
Reproducible Results Use seed values to generate consistent results across multiple runs, essential for iterative refinement and production workflows.

Use Cases

Product Visualization: Transform product photos into different contexts, backgrounds, or styles
Character Art: Create consistent character variations with different poses, outfits, or environments
Style Transfer: Apply artistic styles or visual treatments to existing images
Image Editing: Modify specific aspects of an image through natural language descriptions
Creative Exploration: Generate multiple variations of a concept for selection and refinement
Content Creation: Quickly produce social media content, marketing materials, or creative assets

Supported Formats & Dimensions

Input Image Formats:

JPG, JPEG, PNG
Maximum file size: 10MB
Accepts public URLs or Base64-encoded Data URLs

Output Dimensions:

Width/Height range: 512 to 2048 pixels
Must be divisible by 8
Common sizes: 1024×1024 (square), 1280×720 (widescreen), 1152×864 (standard), 1248×832 (photo), 832×1248 (portrait photo), 864×1152 (portrait), 720×1280 (mobile/vertical), 1344×576 (ultra-wide)

How to Use

Basic Image-to-Image Generation

Upload Reference Image

Provide a public URL or Base64-encoded image in the image field
Ensure the image is in JPG, JPEG, or PNG format and under 10MB

Write Your Prompt

Describe the desired output in the prompt field (max 1500 characters)
Example: "Transform this photo into a watercolor painting style with soft pastel colors"

Select Image Size

Specify dimensions using the size parameter like "10241024" or "1280720"
Choose dimensions that match your use case (square for social media, widescreen for presentations, etc.)

Configure Options

num_images: Set 1-9 to generate multiple variations
prompt_optimizer: Enable for automatic prompt enhancement
seed: Use for reproducible results

Generate

Submit your request and receive generated images as URLs or Base64 strings

Character Reference Generation

For consistent character appearance:

Prepare Portrait Photo

Use a clear, front-facing portrait with good lighting
Single person in frame works best

Configure Character Reference

Use the subject_reference parameter with type "character"
Provide the portrait image URL or Base64 data

Describe the Scene

Write a prompt describing the desired scene, pose, or context
Example: "The character standing on a mountain peak at sunset"

API Parameters

prompt (required): Text description of desired output (max 1500 chars)
image (required): Reference image as URL or Base64 string
size: Image dimensions (e.g., "1024 * 1024", "1280 * 720")
num_images: Number of images to generate (1-9, default: 1)
seed: Random seed for reproducible results
prompt_optimizer: Enable automatic prompt enhancement (boolean)
enable_base64_output: Return Base64 instead of URLs (boolean)
enable_sync_mode: Wait for generation to complete before returning (boolean)
subject_reference: Array of character reference images (optional)

Pricing

$0.0035 per image
Generate multiple images in one request for efficient batch processing
Total cost = $0.0035 × number of images generated

Output Format

Generations return as:

URLs (default): Direct links to generated images hosted on WaveSpeedAI
Base64 (optional): Encoded image data for direct embedding

Response includes:

Unique request ID for tracking
Generation status (created, processing, completed, failed)
Output array with generated image URLs or Base64 data
NSFW content detection flags
Creation timestamp

Best Practices

Use clear, well-lit reference images for best results
For character references, front-facing portraits work best
Enable prompt optimizer if you're new to prompt writing
Use seed values when iterating on a specific result
Generate multiple variations (num_images > 1) to select the best output
Keep prompts descriptive but concise for optimal results

Related Models

Also available on WaveSpeedAI:

minimax/image-01/text-to-image - Generate images from text prompts only

Image 01 Image To Image API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/minimax/image-01/image-to-image with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for Image 01 Image To Image below.

HTTP example

set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "size": "1024*1024",
    "num_images": 1,
    "prompt_optimizer": false
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/minimax/image-01/image-to-image" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL=$(printf '%s' "$TASK" | jq -r '.urls.get // empty')
if [ -z "$RESULT_URL" ]; then
  RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"
fi

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    created|processing) sleep 2 ;;
    *) printf 'Unexpected status: %s
' "$STATUS" >&2; exit 1 ;;
  esac
done

Node.js example

const submitUrl = "https://api.wavespeed.ai/api/v3/minimax/image-01/image-to-image";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "prompt": "A cinematic shot of a city at sunset, soft golden light",
        "size": "1024*1024",
        "num_images": 1,
        "prompt_optimizer": false
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = task.urls?.get ||
  `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout"].includes(result.status)) throw new Error(JSON.stringify(result));
  if (!["created", "processing"].includes(result.status)) throw new Error("Unexpected status: " + result.status);
  await new Promise(resolve => setTimeout(resolve, 2000));
}

Python example

import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "size": "1024*1024",
    "num_images": 1,
    "prompt_optimizer": False
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/minimax/image-01/image-to-image", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = task.get("urls", {}).get("get") or f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout"}:
        raise RuntimeError(result)
    if status not in {"created", "processing"}:
        raise RuntimeError(f"Unexpected status: {status}")
    time.sleep(2)

Image 01 Image To Image API — Frequently asked questions

What is the Image 01 Image To Image API?

Image 01 Image To Image is a MiniMax model for image editing, exposed as a REST API on WaveSpeedAI. MiniMax Image-01 image-to-image model transforms existing images using text prompts. Generate variations, apply style transfers, or modify images with character references. Supports multiple aspect ratios and custom dimensions. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the Image 01 Image To Image API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates production-oriented Python, JavaScript, and cURL examples with timeouts, transient-error handling, and safe GET retries. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/minimax/minimax-image-01-image-to-image.

How much does Image 01 Image To Image cost per run?

Image 01 Image To Image starts at $0.004 per run. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does Image 01 Image To Image accept?

Key inputs: `prompt`, `image`, `size`, `enable_base64_output`, `enable_sync_mode`, `num_images`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/minimax/minimax-image-01-image-to-image.

How long does Image 01 Image To Image take to generate?

Median end-to-end generation time on WaveSpeedAI is around 25 seconds per request, based on recent successful runs. Queue time varies with global demand; live status is visible in the prediction record.

Can I use Image 01 Image To Image outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (MiniMax). The license summary appears on the model card above; see WaveSpeedAI's Terms of Service for platform-level conditions.

관련 모델

README