GPT Image 2 API Deprecation: Migrate to 2.6 Before 2027

Last updated: November 11, 2026. OpenAI has added GPT Image 2 to its API deprecation list. The announcement was posted on November 10, 2026: the gpt-image-2 alias and the pinned gpt-image-2-2026-04-21 snapshot are scheduled to be removed from the API on February 10, 2027.

If your PHP, Laravel, Python, Node.js, ecommerce, or content-production application still calls one of those names, this is an actionable migration rather than a general product announcement. You need to identify the model references, choose an appropriate replacement, compare output quality and cost, and deploy before the retirement date.

OpenAI recommends two replacements: gpt-image-2.6-flare for fast everyday generation and gpt-image-2.6-sunburst for more demanding detail and precision. This guide covers the decision, an API example in PHP, the parameters worth re-testing, operational safeguards, and a pre-cutover checklist. It does not claim that a one-line model substitution guarantees identical images or identical bills.

What Exactly Is Being Deprecated?

The official OpenAI API deprecations page records the November 10 notice and February 10, 2027 shutdown. It lists both the moving alias and the older pinned snapshot, so replacing one literal string in an application is not enough if batch jobs, workers, or service configuration files still reference the other.

Do not confuse deprecation with immediate shutdown. The November 10 announcement is advance notice. The documented shutdown date is February 10, 2027. Conversely, do not assume a still-working API call will keep working after the published retirement date.

Why This Matters for Developers and Website Owners

Image-generation dependencies often appear in unexpected places: an admin dashboard that creates article covers; a nightly batch process that generates product thumbnails; a SaaS image editor; a WordPress integration; a queue worker; a customer-facing design tool; or a fallback model configured in the Responses API.

A shutdown can affect more than the create-image endpoint. Image-editing requests, retry handlers, model allowlists, cost estimators, alerting labels, test fixtures, and file-type assumptions may all be coupled to an old identifier. Applications that generate SEO images also need to preserve dimensions, accessibility text, file size, and publishing workflow after the migration.

For example, an editorial team may receive a landscape image from the API, then convert it to an optimized social cover. Rubic8's Image Resizer can help with the manual resize and WebP workflow, but it does not replace the integration tests that a production API needs.

GPT Image 2.6 Flare vs Sunburst: Which Should You Choose?

OpenAI's GPT Image 2.6 prompting guide describes Flare as the smaller model for workflows where speed matters, and Sunburst as the base model for detailed visual work or editing accuracy. Both can generate and edit images, and both are supported through the Image API.

The word first matters. Do not pick based only on a marketing label. Use the same prompt set, source images, output size, quality setting, and acceptance criteria for both models. OpenAI itself recommends trying Flare on the same tasks after Sunburst meets the quality bar.

Step 1: Find Every Old Model Reference

Search application code, deployment configuration, environment variables, queue definitions, scheduled jobs, serverless functions, templates, tests, and documentation for the deprecated aliases. Include the exact snapshot name.

grep -RniE 'gpt-image-2(-2026-04-21)?' app config routes tests   --include='*.php' --include='*.json' --include='*.js'   --include='*.ts' 2>/dev/null

This is a read-only audit example, not a migration command. Adapt directories to your own application. A search also may match the new gpt-image-2.6-* strings, so inspect each result instead of blindly replacing all occurrences.

Then inspect the request path. Some apps name the image model directly in /v1/images/generations or /v1/images/edits. Others use image tools through the Responses API. A wrapper, provider SDK, or stored database setting may override what you think your code is sending.

Step 2: Replace the Model Explicitly

A simplified PHP configuration might change from:

$payload = [
    'model' => 'gpt-image-2',
    'prompt' => $prompt,
];

to:

$payload = [
    'model' => 'gpt-image-2.6-flare',
    'prompt' => $prompt,
    'quality' => 'medium',
    'complexity' => 'medium',
    'output_format' => 'webp',
];

That snippet illustrates the request parameters; it is not a complete production integration. In the example above, quality controls rendering detail, while complexity controls planning effort. They are separate settings and should be tuned independently.

The safe approach is to centralize model names in a configuration value that can be changed or rolled back without editing every caller. Avoid silently falling back to the deprecated alias if a new-model request fails.

Step 3: Make a Complete PHP Image API Request

The following self-contained PHP example uses the official image-generation endpoint, takes the API key from an environment variable, requests a WebP file, handles transport and HTTP errors, and decodes the API's base64 image data. It requires PHP with the cURL extension. Run it in an authorized development environment with a configured API key; it makes a billable API request.

<?php
$apiKey = getenv('OPENAI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('OPENAI_API_KEY is not configured');
}

$payload = [
    'model' => 'gpt-image-2.6-flare',
    'prompt' => 'A clean editorial illustration of a coastal city at sunrise',
    'size' => '1536x1024',
    'quality' => 'medium',
    'complexity' => 'medium',
    'output_format' => 'webp',
    'n' => 1,
];

$ch = curl_init('https://api.openai.com/v1/images/generations');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CONNECTTIMEOUT => 10,
    CURLOPT_TIMEOUT => 180,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
]);

$response = curl_exec($ch);
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$curlError = curl_error($ch);
curl_close($ch);

if ($response === false) {
    throw new RuntimeException('Image request failed: ' . $curlError);
}
if ($httpCode < 200 || $httpCode >= 300) {
    throw new RuntimeException('Image API HTTP status: ' . $httpCode);
}

$result = json_decode($response, true, 512, JSON_THROW_ON_ERROR);
$b64 = $result['data'][0]['b64_json'] ?? null;
if (!is_string($b64) || $b64 === '') {
    throw new RuntimeException('Image API returned no base64 image');
}

$bytes = base64_decode($b64, true);
if ($bytes === false || $bytes === '') {
    throw new RuntimeException('Image base64 decode failed');
}

$path = __DIR__ . '/generated-image.webp';
if (file_put_contents($path, $bytes, LOCK_EX) === false) {
    throw new RuntimeException('Unable to write image file');
}
echo 'Saved ' . basename($path) . PHP_EOL;

In Laravel, the same ideas apply inside a service class: read the key from server configuration, send the request via your HTTP client, validate the response, store the resulting binary data through Laravel's filesystem, and return the stored asset URL. Use a queue job and idempotency strategy for high-volume generation rather than keeping a user-facing web request open for an unpredictable duration.

Never put the API key in browser JavaScript, public HTML, mobile app source, or logs. Set timeouts and capture failure categories without dumping full sensitive prompts or raw authorization headers into monitoring systems.

Step 4: Validate the JSON Response and the File

A successful HTTP status is not the end of a test. The Image API commonly returns image bytes encoded in a data[0].b64_json field. Decode that value and confirm the produced file opens as the expected format. Check its actual dimensions instead of assuming the requested dimensions always match the file saved by downstream processing.

For development, Rubic8's JSON Validator and JSON Formatter can help inspect a redacted response or a small fixture. Avoid pasting API keys, real user data, large base64 blobs, and private prompts into online tools.

Tests should cover missing data, malformed base64, empty output, service timeouts, rate limits, duplicate job delivery, unexpected content types, incorrect image dimensions, and storage failures. Verify that retries are bounded and do not quietly generate and bill for duplicate images.

Step 5: Recheck Image Size, Formats and Post-processing

For new images, the OpenAI guide documents square, portrait, and landscape dimensions such as 1024x1024, 1024x1536, and 1536x1024. It also documents output formats such as PNG, WebP, and JPEG. Some advanced formats and options have model-specific constraints; consult the current guide before using SVG or animated GIF in production.

A blog cover with a final target of 1200×630 can be generated at a supported landscape size and then deliberately cropped or resized to the publishing template. Do not stretch a square image to a widescreen rectangle. Review the safe area for title overlays and avoid putting critical details close to the edges where a social preview may crop them.

Both GPT Image 2.6 models also support newer features, including SVG output, animated GIF generation, and markup-guided editing through supported Image API paths. Treat those as optional enhancements, not mandatory migration steps. First get the existing PNG/WebP/JPEG pipeline working reliably.

Understanding Quality vs Complexity

These two parameters are easy to mix up:

• quality asks for a rendering quality level, influencing visible details and output characteristics.
• complexity determines how much the model plans before rendering. Supported levels for GPT Image 2.6 include low, medium, and high.

The image-generation documentation says both models default to high complexity when that field is omitted. A lower complexity can work well for a simple local edit; more complex scenes may benefit from additional planning. However, higher complexity may increase latency or cause additional changes, so more is not always better.

OpenAI says there is no separate fee for adjusting complexity. That does not mean every request has identical total token usage, latency, or output cost. Measure the entire operation on your own dataset.

What Happens to API Pricing?

Pricing is not a flat per-image subscription. OpenAI publishes token-based image model pricing, and the actual cost of a generation depends on model usage, input content, output details, and settings.

As listed in the API pricing documentation reviewed on November 11, 2026, both GPT Image 2.6 Flare and Sunburst use the same published base rates in the relevant table: $5 per million text input tokens, $8 per million image input tokens, and $30 per million image output tokens. Prices and availability can change, so check the pricing page when deploying.

Shared token rates do not imply equal cost per successful asset. The models may consume different resources on different tasks, and a faster model that requires several retries may be less economical than a more accurate model that succeeds once.

A more useful operational metric is:

Cost per accepted image = (all generation and retry charges) ÷ number of images that passed review.

Record acceptance rates, retries, output dimensions, average and p95 latency, and total charges for each model and task category. Do not quote the vendor's broad speed claims as your measured production performance.

How Should You Benchmark a Migration?

Use a small set of representative prompts rather than a single impressive example.

For each category, generate multiple samples with the same inputs on Flare and Sunburst. Do blind or structured human review where possible. Record failures such as wrong text, missing objects, changed faces, distorted product dimensions, and unsafe or unlicensed-looking assets. Compare the accepted-image rate alongside billing and latency.

Zero-Downtime Migration Checklist

1. Inventory: find gpt-image-2 and the pinned snapshot in every runtime and job.
2. Confirm access: make sure your organization can use the replacement models and has sufficient rate limits.
3. Centralize config: add an explicit model setting and do not depend on undocumented defaults.
4. Create fixtures: capture representative prompts, input images, dimensions, and acceptance criteria without exporting confidential data.
5. Test generation and edits: check both endpoints used by your application.
6. Validate response handling: decode base64, verify images, and store files safely.
7. Compare cost and speed: use full-task metrics including retries and failed jobs.
8. Canary rollout: enable the new model for a small percentage of traffic or internal users.
9. Monitor: watch error rates, output acceptance, billing changes, and queue backlog.
10. Cut over early: retire the old alias before February 10, 2027.
11. Keep a safe rollback: roll back to the last validated supported configuration, not a model scheduled for retirement.

Common Migration Mistakes

1. Replacing just one alias

Older jobs or pinned snapshots may still send gpt-image-2-2026-04-21. Search all execution paths.

2. Assuming the output is a hosted image URL

The Images API can return base64-encoded output. Handle the actual documented response and save it to your own storage workflow.

3. Comparing only price per token

Measure cost per usable final image after retries, editing and human review.

4. Changing model, format and prompt together

Make one controlled change at a time so you can attribute regressions to a specific cause.

5. Assuming all new features are universally available

SVG, GIF, markup-guided edits, transparency, advanced quality levels and dimensions have API and model constraints. Read the current documentation before relying on them.

6. Publishing without crop and accessibility checks

A visually good generated image can still be a poor article thumbnail. Check its final size, file weight, alt text, and social-preview behavior.

FAQ: GPT Image 2 Deprecation

When does GPT Image 2 stop working in the API?

OpenAI's published shutdown date is February 10, 2027 for both gpt-image-2 and gpt-image-2-2026-04-21.

Has GPT Image 2 already been shut down?

No. As of November 11, 2026 it is deprecated, with the future shutdown date stated above. Your account and endpoint availability may still have other limitations.

Should I use GPT Image 2.6 Flare or Sunburst?

Start with Flare for common speed-sensitive image generation and Sunburst for detailed work or precise edits. Benchmark both with representative tasks before standardizing.

Is there a new API endpoint?

The supported replacements work with the Image API's generation and editing endpoints. The main migration is the model and request behavior; verify parameter compatibility for your implementation.

Does GPT Image 2.6 support SVG and GIF?

OpenAI documents SVG and animated GIF output for GPT Image 2.6 through the Image API. Check output-specific constraints and access requirements in the current guide.

Does lower complexity automatically reduce cost?

No. Complexity has no separate fee, but the full request's token usage and success rate still matter. Compare total cost per accepted image.

Can I use the same prompt after migration?

Yes, start by testing identical prompts, but do not expect pixel-identical outputs or guaranteed parity. Tune the prompt only after you have a controlled baseline.

How should I handle the replacement model in Laravel?

Put the model identifier in configuration, keep your API key on the server, queue long-running work, validate images before saving, and record errors and costs without exposing credentials.

Bottom Line

For developers still using GPT Image 2, the November 10 deprecation notice is a clear maintenance signal. The official cutoff is February 10, 2027, and OpenAI recommends GPT Image 2.6 Flare or Sunburst.

Start with a code and configuration audit. Migrate to an explicit supported model, validate API responses and post-processing, compare cost per accepted image, and roll out with monitoring. The goal is not simply to keep requests returning HTTP 200; it is to preserve the quality, speed and reliability of the images your application actually publishes.

Official Sources

• OpenAI API deprecations — November 10, 2026 notice and February 10, 2027 retirement
• OpenAI API changelog — GPT Image 2.6 release on November 4, 2026
• OpenAI image-generation guide
• OpenAI GPT Image 2.6 prompting guide
• OpenAI API pricing