GPT Image 2: Pricing, API Access and Code (2026)

GPT Image 2 is OpenAI’s newest image model, released on April 21, 2026, and the model behind what ChatGPT calls Images 2.0. Most people searching for it want three answers: what it is actually good at, what each image costs, and how to use it outside the ChatGPT app. This post covers all three, with working API code, a costed example and the mistakes that waste money.

What is GPT Image 2?

GPT Image 2 is a text-to-image model: you give it a written description, called a prompt, and it returns an image. It can also edit or build on images you supply, which are called reference images. It belongs to OpenAI’s GPT Image series, which began with GPT Image 1 (built on GPT-4o) and continued with GPT Image 1.5 in December 2025.

Compared with earlier OpenAI image models, the headline changes are about range and control:

• Three output sizes: 1K, 2K or 4K. “1K” means roughly 1,000 pixels on the long side, 4K roughly 4,000, which is enough for print or large displays.
• The widest aspect ratio range in the OpenAI lineup: auto, 16:9, 1:1, 9:16, 21:9, 9:21, 4:3, 3:4, 3:2, 2:3, 2:1, 1:2, 3:1, 1:3, 5:4 and 4:5. That covers widescreen banners, phone stories, ultra-wide headers and tall infographics without cropping.
• Up to 16 reference images per request, useful for keeping a product, a person or a brand style consistent.
• Multiple outputs per request through an n field, plus a background option.

On Unicorn API the model id is gpt-image-2, and its full spec lives on the GPT Image 2 model page. The same API key also reaches every other model in the catalog, so you can compare it against alternatives without new accounts.

What GPT Image 2 does well, and where it struggles

Reviews and community threads agree on the strengths, and they also agree on a few weak spots. Knowing both saves you from picking the wrong model for a job.

Strengths

• Readable text inside images. Headlines, labels, menus, price tags and slide titles come out legible far more often than with older models. OpenAI specifically called out better rendering of non-Latin scripts, so signage in Japanese, Hindi or Arabic is more usable.
• Dense layouts. Infographics, slides, maps, comic panels and multi-cell grids are where people notice the jump most. Layouts that used to fall apart at a 3x3 grid now hold together.
• Long, specific prompts. It follows detailed instructions about placement, colour and wording well, which matters for product shots and posters.
• Consistency from references. With several reference images, faces and products stay recognisable across a series. If consistent characters are your main goal, our guide to consistent characters via API goes deeper.

Weak spots

• Natural scenes. A common complaint is that GPT Image 2 nails textures like bark, moss and water but misses the rules that hold a landscape together: branches that do not connect properly, terrain that does not recede believably, light that does not match across the frame.
• Cost at high resolution. A 4K image costs well over twice a 1K image. For drafts and social posts that will be viewed on phones, 4K is usually wasted.
• No guaranteed text accuracy. “Much better” is not “perfect”. Long paragraphs and small print still pick up typos, so treat every text-heavy output as something to proofread.

GPT Image 2 pricing per image

OpenAI bundles image generation into ChatGPT plans with usage limits that change over time. If you want a fixed, known price per image, an API is the cleaner route. On Unicorn API, GPT Image 2 pricing depends only on resolution:

Resolution	Credits per image	Cost on a monthly plan ($0.01/credit)	Cost with top-up credits ($0.015/credit)
1K	6	$0.06	$0.09
2K	10	$0.10	$0.15
4K	16	$0.16	$0.24

If you leave resolution out, the request is billed at the 1K price of 6 credits. Prices are per output image, so setting n to 4 multiplies the cost by four.

A worked example

Say you run a small shop and need a weekly batch of marketing images:

• 40 social posts at 1K: 40 x 6 = 240 credits
• 10 product banners at 2K: 10 x 10 = 100 credits
• 2 print posters at 4K, with n set to 2 so you can pick the better one: 2 x 2 x 16 = 64 credits

That is 404 credits a week, or about $4.04 on a monthly plan. Four weeks comes to roughly 1,616 credits, which fits inside the Starter plan ($25 a month for 2,500 credits). For reference, 2,500 credits buys about 416 images at 1K, 250 at 2K or 156 at 4K. Larger plans are Creator at $50, Studio at $100 and Pro at $200 a month, all at $0.01 per credit; see pricing for details. Top-up credits cost more per credit but never expire, which suits irregular use.

You never have to guess a bill: the exact price of any request is available before you run it from POST /v1/models/price, documented in the API docs. That is handy when an app lets users choose resolution and image count.

How to use the GPT Image 2 API

Image generation takes several seconds or more, so the API works with jobs: you create a job, then check on it until it finishes. Here is the full flow.

1. Create an API key on the keys page and store it in an environment variable named UNICORN_API_KEY.
2. Create a job with POST /v1/jobs, sending the model id and an input object.
3. Poll GET /v1/jobs/{id} every few seconds until status is "succeeded".
4. Read the image URL from outputs[0].url and download or display it.

The minimal request with curl

curl -X POST https://api.unicornapi.net/v1/jobs \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-image-2",
    "input": {
      "prompt": "A red fox resting in a snowy forest at dawn, soft light, highly detailed"
    }
  }'

The response includes a job id. Check it with:

curl https://api.unicornapi.net/v1/jobs/JOB_ID \
  -H "Authorization: Bearer $UNICORN_API_KEY"

A complete Python script

This version sets resolution and aspect ratio, waits for the result and prints the image URL:

import os
import time
import requests

API = "https://api.unicornapi.net"
HEADERS = {"Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}"}

payload = {
    "model": "gpt-image-2",
    "input": {
        "prompt": (
            "Minimal product poster for a ceramic coffee mug on a warm beige "
            "background, soft studio light, headline at the top reading "
            "\"Slow Mornings\" in a clean serif font"
        ),
        "resolution": "2K",
        "aspect_ratio": "4:5",
        "n": 1,
    },
}

resp = requests.post(f"{API}/v1/jobs", json=payload, headers=HEADERS)
resp.raise_for_status()
job = resp.json()

while job["status"] != "succeeded":
    if job["status"] == "failed":
        raise RuntimeError(f"Job failed: {job}")
    time.sleep(3)
    poll = requests.get(f"{API}/v1/jobs/{job['id']}", headers=HEADERS)
    poll.raise_for_status()
    job = poll.json()

print(job["outputs"][0]["url"])

This request costs 10 credits (one image at 2K). Change "2K" to "1K" while you iterate on the prompt, then switch back for the final render.

Adding reference images in JavaScript

To keep a real product in the shot, pass reference images in ref_images. The docs list the accepted formats; this example uses public URLs:

const API = "https://api.unicornapi.net";
const headers = {
  "Authorization": `Bearer ${process.env.UNICORN_API_KEY}`,
  "Content-Type": "application/json",
};

const create = await fetch(`${API}/v1/jobs`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    model: "gpt-image-2",
    input: {
      prompt: "Place this exact mug on a wooden cafe table by a rainy window, keep the logo unchanged",
      ref_images: ["https://example.com/mug-front.png"],
      resolution: "1K",
      aspect_ratio: "1:1",
    },
  }),
});
let job = await create.json();

while (job.status !== "succeeded") {
  if (job.status === "failed") throw new Error(JSON.stringify(job));
  await new Promise((r) => setTimeout(r, 3000));
  const poll = await fetch(`${API}/v1/jobs/${job.id}`, { headers });
  job = await poll.json();
}

console.log(job.outputs[0].url);

Prefer not to write code yet? You can run the same model in the browser playground, or call it from Cursor, Claude Code and other coding agents through MCP.

Prompting GPT Image 2 for text, references and layouts

The model rewards specific prompts. A few habits make a large difference.

Text in the image

• Put the exact words in quotation marks: headline reading “Summer Sale, 30% Off”.
• Say where the text goes and how it should look: top centre, bold sans-serif, white on dark green.
• Keep each block short. A headline and a subline work reliably; a paragraph of body copy is where typos creep in.
• For non-English text, name the language and script so the model does not mix them.

Reference images

• Tell the model what to keep from each reference: “keep the logo and label unchanged”, “use this person’s face”, “match this colour palette”.
• More references help consistency, but each should earn its place. Two clean product angles beat eight blurry phone shots.

Aspect ratio and layout

• Pick the ratio for where the image will live: 9:16 for stories, 16:9 for slides and video thumbnails, 4:5 for feed posts, 21:9 or 3:1 for website headers.
• For grids and infographics, describe the structure explicitly: “a 3x3 grid, each cell a different pastry with its name in a label underneath”.

Nature and landscapes

Because natural scenes are a reported weak spot, describe the structure, not just the textures: where the horizon sits, the direction of light, how far the trees are, how the river bends. If the result still feels off, try the same prompt on another model before spending more credits on rewrites.

GPT Image 2 vs GPT Image 1.5, Nano Banana 2 Lite and Flux 3 Klein

GPT Image 2 is not always the right pick. Here is how it compares with other image models you can call with the same key:

Model	Price per image	Output options	Reference images	Best fit
GPT Image 2	6 / 10 / 16 credits (1K / 2K / 4K)	1K to 4K, 16 aspect ratio options	Up to 16	Text-heavy designs, layouts, high-res finals
GPT Image 1.5	3 / 4 / 22 credits (low / medium / high)	1:1, 3:2, 2:3; optional transparent background	Up to 4	Cheap drafts, transparent PNG assets
Nano Banana 2 Lite	4 credits	1K, 7 aspect ratios	Up to 10	Fast, low-cost 1K images and edits
Flux 3 Klein Text to Image	1.6 / 2.5 / 6.5 credits (1K / 2K / 4K), rounded up per request	1K to 4K, custom width and height, seed	None (text only)	High-volume generation on a tight budget
Flux 3 Klein Edit Image	1.6 / 2.5 / 6.5 credits (1K / 2K / 4K), rounded up per request	1K to 4K	Input images via image_urls	Budget image edits

A few practical readings of this table:

• GPT Image 2 vs GPT Image 1.5: 1.5 is cheaper for drafts (3 or 4 credits), but its high quality setting costs 22 credits, more than GPT Image 2 at 4K. If you need a transparent background, 1.5 explicitly supports it. If you need wide or tall formats or more than 4 references, use GPT Image 2.
• Nano Banana 2 Lite is the cheapest Gemini image model at 4 credits, a good choice for quick 1K images. More on Google’s lineup in our Nano Banana pricing breakdown.
• Flux 3 Klein is the lowest-cost option. Billing rounds up to whole credits per request, so a single 1K image costs 2 credits, while 5 images at 1K (num_images set to 5) cost 8 credits. Batching makes it cheaper per image.

A common setup is to draft with a cheap model, then render the final with GPT Image 2 at 2K or 4K. Since every model sits behind one key and one bill, switching is a one-line change to the model field.

Can you try GPT Image 2 free with no sign-up?

Searches for “gpt image 2 free no sign-up” are common, so here is a straight answer. OpenAI makes GPT Image 2 available inside ChatGPT, including some access on free accounts, but that requires an OpenAI account and the limits shift over time. Various third-party sites advertise free generation with the model; they usually offer a handful of images, then ask you to register or pay, and some add watermarks or reduce resolution.

Truly unlimited, free and anonymous access to GPT Image 2 does not exist in a reliable form, because every image costs real compute. If you only need a few images, ChatGPT is the simplest route. If you need images inside a product, in batches, or at a predictable price, an API is more practical: at 6 credits for a 1K image, a hundred test images costs $6 on a monthly plan.

Common mistakes with GPT Image 2

1. Rendering everything at 4K. Iterate at 1K for 6 credits, then render the winner at 2K or 4K. Most screens never show the difference.
2. Forgetting that n multiplies the price. Four variations at 4K is 64 credits, not 16. Check with the price endpoint if users control n.
3. Vague text instructions. “Add a title” invites made-up words. Quote the exact text and say where it goes.
4. Skipping the proofread. Text rendering is strong, not flawless. Read every word before an image goes public, especially prices and names.
5. Using it for every job. Simple 1K illustrations may be just as good on a 4-credit or 2-credit model. Match the model to the task.
6. Polling too fast or not handling failures. Poll every few seconds, stop on a failed status and log the job for debugging, as in the code above.
7. Ignoring aspect ratio. Generating 1:1 and cropping to 9:16 throws away composition. Ask for the final ratio from the start.

GPT Image 2 is the strongest OpenAI image model for text, layouts and consistent references, with a clear price per image once you call it through an API. Start with a key from the keys page, run the Python script above at 1K, and scale up resolution only for the images that ship.