Minimax Image 01 Image To Image API Documentation

Minimax Image 01 Image To Image API Documentation

Playground

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.

Features

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

1. 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

2. 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”

3. 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.)

4. Configure Options

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

5. Generate

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

Character Reference Generation

For consistent character appearance:

1. Prepare Portrait Photo

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

2. Configure Character Reference

• Use the subject_reference parameter with type “character”
• Provide the portrait image URL or Base64 data

3. 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

Authentication

For authentication details, please refer to the Authentication Guide.

API Endpoints

Submit Task & Query Result

set -euo pipefail

export WAVESPEED_API_KEY="your-api-key"

REQUEST_BODY=$(cat <<'JSON'
{
  "prompt": "A cinematic ocean wave at sunrise, highly detailed",
  "size": "1024*1024",
  "num_images": 1,
  "prompt_optimizer": false
}
JSON
)

# 1. Submit the prediction once. Never retry this request automatically:
# a retry after an unclear failure can create a second, billed task.
CHECK='The task may already exist. Check History or the predictions list before submitting again.'
if ! SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  --connect-timeout 10 --max-time 60 \
  -X POST "https://api.wavespeed.ai/api/v3/minimax/image-01/image-to-image" \
  -H "Authorization: Bearer ${WAVESPEED_API_KEY}" \
  -H "Content-Type: application/json" \
  -d "${REQUEST_BODY}"); then
  printf 'Submit failed. %s\n' "${CHECK}" >&2
  exit 1
fi

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

# 2. Poll until the prediction reaches a final status.
BODY_FILE=$(mktemp)
trap 'rm -f "${BODY_FILE}"' EXIT
while true; do
  # Transient errors (429, 5xx) are retried, honoring Retry-After.
  HTTP_CODE=$(curl --silent --show-error --fail-with-body \
    --connect-timeout 10 --max-time 60 --retry 5 --retry-delay 2 \
    --output "${BODY_FILE}" --write-out '%{http_code}' \
    "${RESULT_URL}" \
    -H "Authorization: Bearer ${WAVESPEED_API_KEY}" || true)
  case "${HTTP_CODE}" in
    2??) ;;
    000|429|5??)  # dropped connection or temporary error: keep polling
      printf 'Task %s: HTTP %s, polling again in 10s\n' "${PREDICTION_ID}" "${HTTP_CODE}" >&2
      sleep 10; continue ;;
    *) printf 'Task %s: HTTP %s\n' "${PREDICTION_ID}" "${HTTP_CODE}" >&2
      cat "${BODY_FILE}" >&2; exit 1 ;;
  esac
  RESULT=$(jq 'if type == "object" and has("data") then .data else . end' "${BODY_FILE}")
  STATUS=$(printf '%s' "${RESULT}" | jq -r '.status // empty')

  case "${STATUS}" in
    completed) printf '%s\n' "${RESULT}" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted)
      printf 'Task %s ended with status %s\n' "${PREDICTION_ID}" "${STATUS}" >&2
      printf '%s\n' "${RESULT}" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done

Parameters

Task Submission Parameters

Request Parameters

Every model also accepts the global request options enable_sync_mode and enable_base64_output; see their pages for details.

Response Parameters

Result Request Parameters

Result Response Parameters