ChatGPT Images 2.0: Features, Use Cases, and Impact

What Shipped on April 21

The release has three surfaces: the model itself, the consumer product in ChatGPT, and a developer API surface through gpt-image-2 and the chatgpt-image-latest alias. Each surface maps to a different user inside an agency: the creative lead exploring prompts in ChatGPT, the developer wiring programmatic generation into a production workflow, and the operations lead deciding which tier to buy.

Context on the lineage matters here. Images 2.0 succeeds GPT-Image-1.5, released in December 2025, which introduced improved instruction following, better color, and stronger lighting. OpenAI is now deprecating GPT-Image-1.5 as the default model across its suite, though it will remain accessible via the API for legacy workflows. Before launch, Images 2.0 ran for weeks on LM Arena under the codename “duct tape” — so if you saw an unusually strong unreleased model in blind comparisons over the past month, this is the reveal.

Instant vs Thinking Modes

The biggest conceptual change in this release is that ChatGPT Images 2.0 is not one model — it is a spectrum from fast default generation to slower, more agentic, more structured generation. The base model is the default. Thinking layers OpenAI's O-series reasoning on top — the system researches, plans, and reasons through layout before the first pixel is rendered, pulls web search and uploaded documents into the process, and returns up to eight consistent images with character and object continuity from a single request. Pro users additionally get access to an ImageGen Pro layer; OpenAI has not fully differentiated what that adds beyond Thinking itself.

For pure speed — social posts, quick variations, A/B ideation — stay on the base model. Thinking is worth the extra time on information-dense creative: infographics that need accurate data, academic-style explainers, multi-panel comic sequences, storyboards that require cross-frame continuity, or workflows where the model needs to synthesize an uploaded document (a deck, a PDF brief, a spreadsheet) into a produced visual. During OpenAI's launch briefing, ChatGPT Images Product Lead Adele Li demonstrated exactly that — uploading an internal PowerPoint on product strategy and watching Thinking produce a professional poster that preserved the deck's data, logos, and stylistic inputs.

Text Rendering — The Real Upgrade

If there is one capability that deserves to lead the conversation, it is this: text rendering. OpenAI's launch materials lean hard on structured, information-rich visuals — posters with editorial copy, magazine-style infographics, academic diagrams, annotated product grids, bookmarks with bleed and trim guides. That is not a decorative choice. It is the signal that the model can finally place readable characters where you asked for them.

The commercial impact is bigger than it sounds. The difference between a model that is fun for inspiration and one that is useful for production work has almost always lived at the typographic layer. Readable text inside images unlocks a set of workflows that previous generations could only gesture at:

• Ad mockups with actual headlines, not Lorem Ipsum placeholders.
• Landing page concept visuals where the hero copy reads correctly at export.
• Social creative with legible copy in-image — critical for feeds that truncate alt text.
• Branded event posters and product launch graphics with real dates, SKUs, and names.
• Explainer visuals and internal training decks with readable labels, callouts, and axes.
• Infographic-style educational content where the chart itself has to be correct.

Stronger Across Languages

The second standout theme is multilingual performance. OpenAI positions Images 2.0 as a “polyglot” model with significant gains in non-Latin script rendering, specifically calling out Japanese, Korean, Chinese, Hindi, and Bengali. The launch gallery ranges from a manga-style comic page in Japanese to bookstore displays with South Asian language covers, Korean hospitality brochures, and multilingual typography posters spanning Devanagari, Cyrillic, Greek, Arabic, and Chinese — plus educational diagrams that render complex Korean Hangul inside a working water-cycle explainer.

Multilingual visual generation is historically harder than it sounds. It is not only a translation problem — it is a layout problem, a typography problem, a spacing problem, and often a cultural coherence problem. A decent generator can hit any single one of those. A useful one has to hit all of them in the same output. The launch materials suggest ChatGPT Images 2.0 handles that combination more convincingly, whether the brief is a Japanese manga page, a Korean café campaign, or a book cover series across South Asian scripts.

Editing as a First-Class Workflow

OpenAI's help docs are explicit that ChatGPT Images is not just a generator. You can upload an existing image and edit it — either by selecting a specific region and describing a change, or by describing a broader edit in conversation. OpenAI notes that selected areas are not always perfectly precise and edits can extend beyond the highlighted region, which is important to plan for but does not change the shape of the workflow.

Real creative work is iterative. Teams do not need a single perfect image on the first try — they need a fast loop that matches how design review actually happens:

1. Generate a first concept.
2. Change the layout.
3. Revise the text.
4. Swap background or subject details.
5. Test alternate crops or aspect ratios.
6. Export and move on.

Aspect ratio flexibility is part of that loop. You can generate in any ratio from 3:1 ultra-wide to 1:3 ultra-tall — either using the picker in ChatGPT or by specifying the ratio in the prompt. That range covers social formats, banner ads, mobile vertical, editorial spreads, and print-oriented compositions without a post-processing step. Combined with editing, it turns ChatGPT Images 2.0 from “make image” into “make, revise, localize, reframe, and reuse.”

Mask-based edits for pixel-region control

For developers wiring this into a product, the API exposes mask editing as a first-class primitive. You provide the source image, a mask that flags the region to change, and a prompt describing the change. A few requirements to respect:

• Alpha channel required.The mask image must carry an alpha channel. Pure black-and-white masks need to be converted (OpenAI's docs include a six-line Python snippet using Pillow to add the alpha).
• Same format and size as the source image, and the mask file must be under 50MB.
• Mask guidance is prompt-based, not pixel-perfect. The model uses the mask shape as a hint and may extend edits slightly beyond the selected region. Plan for one revision pass on precision-critical edits.
• Multiple inputs, first-image masking. If you pass multiple input images with a mask, the mask is applied to the first image only.

Multi-image references for product compositing

The Image API's edit endpoint accepts multiple reference images in a single call. OpenAI's own example uses four product shots (body lotion, bath bomb, incense kit, soap) and a single prompt to produce a photorealistic “Relax & Unwind” gift basket. For agencies, this is a real unlock — product compositing, lifestyle mockups from existing packshots, branded gift bundles, even character reference sheets built from a small set of inputs — all without a designer hand-masking in Photoshop.

Multi-turn editing with the Responses API

In the Responses API, the image generation tool accepts an action parameter that controls the turn behavior:

• action: "auto" (default) — the model decides whether to generate a new image or edit an existing one in context.
• action: "generate" — always produce a new image from scratch, ignoring prior context.
• action: "edit" — force an edit; the call errors if there is no image already in context.

Chain turns by passing previous_response_id on follow-up calls (simpler) or by including the previous image_generation_call ID in the input (more explicit). The result is a conversational edit loop that feels closer to working with a collaborator than re-prompting a generator.

Availability and Tier Rollout

OpenAI made a notable choice here: the base Images 2.0 model is available on every ChatGPT tier, while Thinking is reserved for Plus and Pro, and Pro gets an additional ImageGen Pro layer on top. Instead of gating the core quality jump behind a premium subscription, the quality floor goes up for everyone, and the reasoning, multi-image, and web-search ceiling sits at the paid tiers.

One caveat on the matrix above: OpenAI has not published a crisp Pro-versus-Thinking feature differentiation at launch. Treat Thinking as the meaningful functional upgrade and ImageGen Pro as a higher-end access tier whose exact incremental benefits still need clarification before procurement or workflow planning. For Enterprise and Education tiers, confirm availability directly in the admin console — OpenAI has not published a consolidated tier matrix as of launch.

GPT-Image-1.5 and DALL·E both stay on the board, with caveats. OpenAI is deprecating GPT-Image-1.5 as the default model across ChatGPT, though it remains accessible via the API for legacy workflows. The DALL·E GPT still lives inside ChatGPT, and images generated through it are labeled accordingly. For new work, default to ChatGPT Images 2.0 — especially anything that needs readable text, multilingual handling, 4K output, or flexible aspect ratios. Keep the older models around only for prompt libraries already tuned to them.

Developer API: gpt-image-2 + Responses API

This launch is not only a ChatGPT feature story. OpenAI exposes the same image stack to developers through two endpoints:

• Image API — best for one-shot image generation or a single edit pass. Versioned model ID: gpt-image-2.
• Responses API — best for conversational and multi-step image workflows where context accumulates across turns. Image generation surfaces as a built-in tool. chatgpt-image-latest is an alias that always points to the snapshot used inside ChatGPT, so product teams who want parity with what users see can pin to that.

A minimal single-image generate call looks like this:

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.images.generate({
  model: "gpt-image-2",
  prompt: "Editorial poster titled 'Stronger Across Languages' with multilingual typography",
  size: "1024x1024",
  quality: "high",
});

const b64 = response.data[0].b64_json;

Pricing runs in two layers. Per-image pricing on gpt-image-2 at 1024×1024 is $0.006 low / $0.053 medium / $0.211 high. Portrait 1024×1536 and landscape 1536×1024 come in at $0.005 / $0.041 / $0.165. Token pricing runs $8/M image input, $2/M cached image input, $30/M image output, $5/M text input, $1.25/M cached text input, and $10/M text output. For migrations from GPT-Image-1.5, this is a straight cost reduction at every quality tier — full matrix in the next section.

Beyond pricing, a few technical details worth factoring into a production workflow:

• Supported sizes and resolutions. Any resolution where both edges are multiples of 16px, the max edge is ≤3840px, the long-to-short ratio is ≤3:1, and total pixels land between 655,360 and 8,294,400. Popular sizes include 1024×1024, 1536×1024, 1024×1536, 2048×2048 (2K), 3840×2160 (4K), and 2160×3840 (4K portrait). Outputs above 2560×1440 are flagged experimental by OpenAI.
• Streaming with partial images. Both the Image API and Responses API support streaming. Use the partial_images parameter (0–3) to deliver in-progress frames for an interactive UX. Each partial image adds +100 image output tokens to total cost.
• Transparent backgrounds. gpt-image-2 does not currently support transparent backgrounds — requests with background: "transparent" fail. If you need transparent outputs, fall back to GPT-Image-1.5 for that specific branch of your pipeline.
• Input fidelity is fixed. Unlike earlier models, gpt-image-2 always processes image inputs at high fidelity — omit the input_fidelity parameter entirely. Reference-heavy edit requests can use more input tokens than before, which is worth budgeting for.
• Responses API tool model. The image generation tool runs under a mainline model — OpenAI shows gpt-5.4 in its official examples. For multi-turn conversational edits, use the tool form; the Image API is the right choice for one-shot generation.
• Moderation controls. The moderation parameter accepts auto (default) or low. Content policy applies in both; this only shifts the strictness of age-appropriate filtering.

Output Customization and Token Economics

Between pricing and the agency playbook sits a layer most launch coverage skips entirely: the controls that actually shape the output file on disk, and the way gpt-image-2 charges for output tokens under the hood. Both matter for production pipelines.

File format, compression, and background

The Image API returns base64-encoded image data. The default format is png, but you can also request jpeg or webp. For JPEG and WebP you can pair the format choice with output_compression (0–100%) to dial file size. OpenAI explicitly notes that JPEG is faster than PNG — if latency is a concern, default to JPEG and only fall back to PNG when the use case demands lossless output.

The background parameter takes opaque or auto — gpt-image-2 does not currently support transparent (requests that set it fail). For transparent-background outputs, route that specific step to GPT-Image-1.5 in your pipeline.

Full size constraints (not just “1024 / 2K / 4K”)

OpenAI says gpt-image-2 supports “thousands of valid resolutions” — not only the popular sizes. Any resolution passes if it satisfies four constraints:

• Maximum edge length must be ≤ 3840px.
• Both edges must be multiples of 16px.
• Long-edge-to-short-edge ratio must not exceed 3:1.
• Total pixels must be between 655,360 and 8,294,400.

Anything above 2,560×1,440 (3,686,400 pixels) is flagged experimental. OpenAI also notes that a larger non-square resolution can sometimes produce fewer output tokens than a smaller square one at the same quality setting — worth testing in your own workload before committing to a default size.

Token economics: gpt-image-2 is calculated, not tabulated

This is the point most launch coverage gets wrong. OpenAI ships a calculator for gpt-image-2 that returns the output-token count dynamically based on requested quality and size — not a fixed token table like earlier models. To pull a real number from the official docs: a 1024×1024 image at Low quality on gpt-image-2 runs 196 output tokens. That is the token count that gets multiplied by the $30/M image-output token rate to produce the per-image $0.006 figure in the pricing table.

GPT Image models prior to gpt-image-2 used a static table — which is why the legacy costs are easier to reason about in bulk:

Note: the table above is for pre-gpt-image-2 models. For gpt-image-2 specifically, always pull the output-token count from the calculator in the official image-generation guide — the number changes with quality and exact size.

The full cost formula

For any request, the total cost sums three parts:

• Input text tokens — the prompt itself, at $5/M.
• Input image tokens — only relevant for the edits endpoint or reference-image workflows. At $8/M. Note that gpt-image-2 always processes image inputs at high fidelity, so reference-heavy requests cost more per call than on earlier models.
• Image output tokens — the calculated output at $30/M. This is where your volume budget actually lives.

Streaming with partial_images (0–3) adds +100 image output tokens per partial image. On a typical production flow that streams two partials for the UX, that is +200 tokens on top of the final output — small per request, but meaningful at campaign scale.

Pricing Comparison Across GPT Image Models

The easy way to judge gpt-image-2's commercial positioning is to line it up against OpenAI's earlier GPT Image models, all of which remain available through the API. The table below pulls per-image pricing directly from the official OpenAI API docs for three common sizes. Numbers are USD per generated image, before token input costs.

Three practical observations for agency planning. First, gpt-image-2 is priced below GPT-Image-1.5 at every quality tier for every listed size. Moving default production work from 1.5 to 2 is pure upside: better quality, lower unit cost, more capabilities. Second, GPT-Image-1-Mini remains the cheapest model in the stack and still has a role for high-volume, low-stakes generation — thumbnails, quick drafts, internal ideation. Third, landscape and portrait formats are cheaper than square at every quality tier on gpt-image-2; useful when the brief is aspect-ratio-flexible.

Agency Playbook — Where It's Strongest

Based on OpenAI's own launch gallery, ChatGPT Images 2.0 concentrates its strengths in five areas. Each of them maps cleanly to a deliverable an agency already charges for.

Safety, Watermarking, and Provenance for Agency Work

OpenAI is wrapping Images 2.0 in what it describes as a multi-layered safety stack. For agencies producing client-facing work — especially anything touching regulated industries, political advertising, or public campaigns — the provenance layer is the piece that matters operationally.

The practical implication for agency operations is simple: treat Images 2.0's provenance layer as the default, and make provenance preservation part of your asset-delivery checklist. Strip it in transit (by re-encoding through a tool that discards metadata, for example) and you lose the audit trail. That is a documented-and-shipped hygiene problem, not a model limitation.

Open Questions and Limitations

The launch is strong but not unlimited. OpenAI itself calls out four explicit limitations in the official docs, and a few operational caveats matter on top of those before committing production workflows.

OpenAI's own four caveats

Operational caveats worth planning around

Final Thoughts

ChatGPT Images 2.0 is a meaningful step forward because it targets the parts of image generation that matter most in real workflows: text accuracy, instruction following, multilingual handling, editing, and format flexibility. Those are the capabilities that separate tools that are impressive in demos from tools that earn a line on a production asset pipeline.

The broader signal is also worth reading. Image generation is becoming less isolated and more integrated with reasoning, conversation, editing, and developer tooling. Instant and Thinking inside ChatGPT, plus gpt-image-2 and the Responses API, together look less like a single-purpose generator and more like the spine of a complete visual workflow.

For teams shipping creative at speed, that is the real headline. ChatGPT Images 2.0 is not just about prettier pictures. It is about making AI-generated visuals more controllable, more editable, and more usable in practical business contexts — the work that actually gets invoiced.

Frequently Asked Questions