Key features

Text→Image generation: converts natural-language prompts into images with strong instruction following.
Image editing / inpainting: accepts reference images and masks to perform targeted edits.
Cost-optimized (“mini”) design: a smaller footprint that OpenAI and observers describe as much cheaper per image than the large model (OpenAI/DevDay messaging and early reports say ~80% less expensive).
Flexible output controls: supports size, output format (JPEG/PNG/WEBP), compression and a quality knob (low/medium/high/auto in the cookbook).

Technical details (architecture & capabilities)

Model family & input/output: member of the gpt-image-1 family; accepts text prompts and image inputs (for edits) and returns generated image outputs. Quality/size parameters control resolution (typical max ~1536×1024 in this family—see docs for exact supported sizes).
Operational tradeoffs: engineered as a smaller footprint model—trades some top-end fidelity for throughput and cost improvements while preserving robust prompt-following and edit features.
Safety & metadata: follows OpenAI’s image safety guardrails and embeds C2PA metadata options for provenance when available.

Inputs & outputs — canonical usage supports:

Text prompt (string) to generate a new image.
Image + mask to perform targeted edits/inpainting.
Reference images to control style or composition.
These are exposed via the Images API (model name gpt-image-1-mini).

Limitations

Lower peak fidelity: compared with the large gpt-image-1 model, mini may lose some micro-detail and top-end photorealism (expected tradeoff for cost).
Text rendering & tiny details: like many image models, it can struggle with small legible text, dense charts, or micro-fine textures; expect to post-process or use higher-capacity models for those needs.
Edit scope: image edit/inpainting features are available but suggest some editing limitations relative to interactive ChatGPT web tools—edits are effective for many tasks but may require iterative refinement.
Safety & policy constraints: outputs are subject to OpenAI moderation/safety guardrails (explicit content, copyrighted content restrictions, disallowed outputs). Developers can control moderation sensitivity via API parameters where offered.

Recommended use cases

High-volume content generation (marketing assets, thumbnails, rapid concept art) — where cost per image is primary.
Programmatic editing / templating — bulk inpainting or variant generation from a base asset.
Interactive applications with budget constraints — chat interfaces or integrated design tools where response speed and cost matter more than absolute top fidelity.
Prototyping & A/B image generation — generate many candidate images quickly and selectively upscale or re-run on larger models for finalists.
How to access gpt-image-1-mini API

Log in to cometapi.com. If you are not our user yet, please register first. Sign into your CometAPI console. Get the access credential API key of the interface. Click “Add Token” at the API token in the personal center, get the token key: sk-xxxxx and submit.

Step 2: Send Requests to gpt-image-1-mini API

Select the “\**gpt-image-1-mini \**”endpoint to send the API request and set the request body. The request method and request body are obtained from our website API doc. Our website also provides Apifox test for your convenience. Replace <YOUR_API_KEY> with your actual CometAPI key from your account.

Insert your question or request into the content field—this is what the model will respond to . Process the API response to get the generated answer.

Step 3: Retrieve and Verify Results

Process the API response to get the generated answer. After processing, the API responds with the task status and output data.

Pricing for GPT Image 1 mini

Explore competitive pricing for GPT Image 1 mini, designed to fit various budgets and usage needs. Our flexible plans ensure you only pay for what you use, making it easy to scale as your requirements grow. Discover how GPT Image 1 mini can enhance your projects while keeping costs manageable.

Comet Price (USD / M Tokens)	Official Price (USD / M Tokens)	Discount
Input:$6.4/M Output:$25.6/M	Input:$8/M Output:$32/M	-20%

Sample code and API for GPT Image 1 mini

gpt-image-1-mini is a cost-optimized, multimodal image model from OpenAI that accepts text and image inputs and produces image outputs. It is positioned as a smaller, cheaper sibling to OpenAI’s full GPT-Image-1 family — designed for high-throughput production use where cost and latency are important constraints. The model is intended for tasks such as text-to-image generation, image editing / inpainting, and workflows that incorporate reference imagery.

#!/bin/bash
# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here

# Output directory
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
OUTPUT_DIR="$SCRIPT_DIR/../output"
mkdir -p "$OUTPUT_DIR"

curl -s -X POST "https://api.cometapi.com/v1/images/generations" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-1-mini",
    "prompt": "A cute baby sea otter swimming in the ocean",
    "size": "1024x1024"
  }' \
  | jq -r '.data[0].b64_json' | base64 --decode > "$OUTPUT_DIR/output.png"

echo "Image saved to: $OUTPUT_DIR/output.png"

cURL Code Example

#!/bin/bash
# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here

# Output directory
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
OUTPUT_DIR="$SCRIPT_DIR/../output"
mkdir -p "$OUTPUT_DIR"

curl -s -X POST "https://api.cometapi.com/v1/images/generations" \
  -H "Authorization: Bearer $COMETAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-1-mini",
    "prompt": "A cute baby sea otter swimming in the ocean",
    "size": "1024x1024"
  }' \
  | jq -r '.data[0].b64_json' | base64 --decode > "$OUTPUT_DIR/output.png"

echo "Image saved to: $OUTPUT_DIR/output.png"

Python Code Example

import base64
import os
from openai import OpenAI
from PIL import Image
from io import BytesIO

# Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
COMETAPI_KEY = os.environ.get("COMETAPI_KEY") or "<YOUR_COMETAPI_KEY>"
client = OpenAI(api_key=COMETAPI_KEY, base_url="https://api.cometapi.com/v1")

# Output directory
OUTPUT_DIR = os.path.join(os.path.dirname(__file__), "..", "output")
os.makedirs(OUTPUT_DIR, exist_ok=True)

prompt = "A cute baby sea otter swimming in the ocean"

# Generate image using gpt-image-1-mini
result = client.images.generate(
    model="gpt-image-1-mini",
    prompt=prompt,
    size="1024x1024",
)

# Save the image
image_base64 = result.data[0].b64_json
image_bytes = base64.b64decode(image_base64)

output_path = os.path.join(OUTPUT_DIR, "output.png")
image = Image.open(BytesIO(image_bytes))
image.save(output_path, format="PNG")

print(f"Image saved to: {output_path}")

JavaScript Code Example

import OpenAI from "openai";
import * as fs from "node:fs";
import * as path from "node:path";
import { fileURLToPath } from "node:url";

// Get your CometAPI key from https://api.cometapi.com/console/token, and paste it here
const COMETAPI_KEY = process.env.COMETAPI_KEY || "<YOUR_COMETAPI_KEY>";
const BASE_URL = "https://api.cometapi.com/v1";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const client = new OpenAI({
  apiKey: COMETAPI_KEY,
  baseURL: BASE_URL,
});

async function main() {
  // Output directory
  const outputDir = path.join(__dirname, "..", "output");
  if (!fs.existsSync(outputDir)) {
    fs.mkdirSync(outputDir, { recursive: true });
  }

  const prompt = "A cute baby sea otter swimming in the ocean";

  // Generate image using gpt-image-1-mini
  const result = await client.images.generate({
    model: "gpt-image-1-mini",
    prompt: prompt,
    size: "1024x1024",
  });

  // Save the image
  const imageBase64 = result.data[0].b64_json;
  const outputPath = path.join(outputDir, "output.png");
  fs.writeFileSync(outputPath, Buffer.from(imageBase64, "base64"));

  console.log(`Image saved to: ${outputPath}`);
}

main();

GPT Image 1 mini