The Complete Guide to GPT-5.4 Migration — What to Do Before July 23 Retirement and How to Transition Smoothly

Migrating from GPT-5.4 before its retirement (Deadline: July 23, 2026)

Date context: July 2026. This guide is an in-depth, practical migration playbook for teams, developers, and enterprises who must move workloads from GPT-5.4 before its scheduled retirement on July 23, 2026. It consolidates official timeline details, replacement model mappings (GPT-5.5, GPT-5.5 Pro, GPT-5.6 Sol/Terra/Luna), API endpoint and compatibility changes, prompt compatibility guidance, pricing and benchmark comparisons, migration checklists, testing strategies, enterprise considerations, and a decision matrix for choosing the correct replacement.

Who should read this

• Platform engineers running production services powered by GPT-5.4 APIs
• AI/ML engineers maintaining fine-tunes, embeddings, or pipelines built around GPT-5.4
• Product managers and enterprise IT owners preparing compliance and audit traces for model changes
• Developers and prompt engineers needing to validate prompt compatibility and latency SLAs

Executive summary

OpenAI’s official retirement schedule for GPT-5.4 takes effect on July 23, 2026. On that date, live API access to the model will be blocked; requests to the GPT-5.4 model name will return explicit deprecation errors. Replacement models (GPT-5.5, GPT-5.5 Pro, and the GPT-5.6 family: Sol, Terra, Luna) are available and cover common migration needs: cost-sensitive workloads, high-throughput production workloads, and advanced multimodal/long-context reasoning. This guide provides prescriptive migration steps, code examples, regression testing recipes, a compatibility matrix, pricing and performance comparisons, and enterprise migration considerations to complete the move with minimal risk.

Official timeline: What happens on July 23, 2026

OpenAI published a formal deprecation notice in June 2026 establishing the following timeline and behaviors. Treat these as the canonical actions you must design for:

1. July 23, 2026 (00:00 UTC) — GPT-5.4 stops accepting new inference requests. API calls that reference the GPT-5.4 model name will return a deprecation error with HTTP 410 (Gone) and an explanatory payload that includes recommended replacement models.
2. Grace period for stored resources (30 days) — For 30 days after July 23, GPT-5.4 artifacts (logs, analytics, billing records, fine-tune meta-data) remain available for read access through management APIs. Inference endpoints will still be blocked.
3. Fine-tunes and historic runs — Fine-tuned models built on GPT-5.4 will be marked read-only. OpenAI recommends re-training or migrating fine-tunes to GPT-5.5/5.6 flavors; an automated migration tool is provided (see the “Fine-tune migration” section).
4. ChatGPT web/app experience — For accounts currently pinned to GPT-5.4-based custom assistants, ChatGPT will switch those assistants to the selected fallback (default: GPT-5.5). Administrators can change the fallback before retirement using the Admin Center.
5. Billing and tokens — Billing will stop for live GPT-5.4 inferences after the cutoff. Historical usage remains visible and billable as usual for past usage. No prorated refunds will be automatically issued: consult billing notices for migration credits that may be offered.

What exactly gets blocked on July 23

• All live inference calls to model name “gpt-5.4” (API error: HTTP 410).
• Programmatic streaming sessions to the same model signature.
• New fine-tune jobs initiated against base “gpt-5.4”.
• Newly created chat assistant instances explicitly bound to gpt-5.4 for inference.

What remains accessible

• Stored logs, billing history, analytics, and metadata for 30 days post-retirement for extraction.
• Exports of conversation transcripts and assistant configurations (administrators must export before deletion windows for long-term archives).
• Support tooling for migration (OpenAI-provided migration scripts and testing consoles are active in the console until July 23).

Which models replace GPT-5.4

OpenAI announced a set of replacement models to cover different performance, cost, and capability tradeoffs. Below are the replacement models and a short capability summary. Treat these as your canonical mapping options; pick the model whose characteristics align with your production requirements.

• GPT-5.5 — The direct successor to GPT-5.4. Improved latency, slightly better reasoning, and minor improvements on factuality. Drop-in compatibility for most applications with minimal prompt revisions.
• GPT-5.5 Pro — Higher throughput and extended context windows (up to 512k tokens for selected enterprise tiers), prioritized compute for lower tail latency, and better streaming throughput. Recommended for high-concurrency production systems.
• GPT-5.6 family:
  • GPT-5.6 Sol — Cost-optimized member of the 5.6 family for token-sensitive workloads (reduced per-token price with conservative sampling defaults to maintain throughput).
  • GPT-5.6 Terra — Enterprise-grade model with enhanced reasoning quality, stronger multi-step plan execution, and extra deterministic response modes for audit-sensitive workflows.
  • GPT-5.6 Luna — Multimodal-first variant with improved image grounding, multi-document context fusion, and advanced retrieval-augmented generation primitives out-of-the-box.

High-level recommendation

If you want the easiest, fastest migration with minimal prompt changes: use GPT-5.5. If you have high-QPS production systems with strict latency SLAs, consider GPT-5.5 Pro. If your workloads require either cost-optimized inference (large scale but tolerant of slightly lower sampling variability) or multimodal capabilities, choose GPT-5.6 Sol or Luna respectively. For audit-sensitive reasoning tasks where determinism and traceability are essential, pick GPT-5.6 Terra.

Internal migration links

Use the following internal references for deeper workstream items as you migrate:

For a deeper exploration of ChatGPT prompting techniques, our comprehensive guide on Why OpenAI Killed Legacy Models and What the Streamlined ChatGPT Means for Enterprise AI Strategy provides detailed walkthroughs, practical examples, and expert recommendations that complement the strategies discussed in this section.

,

Teams implementing these workflows will benefit from understanding the foundational concepts covered in our detailed analysis of How OpenAI’s $30 Billion Revenue Target Is Reshaping the AI Industry: From Research Lab to Enterprise Platform, which examines the technical architecture and best practices for production deployments.

,

The techniques described above build upon the principles outlined in our in-depth tutorial on How Enterprise AI Governance Is Evolving in 2026: From Microsoft Purview to OpenAI’s Built-In Compliance Tools, where we examine real-world implementation patterns and performance optimization strategies.

,

Organizations evaluating these capabilities should also review our thorough examination of What’s New in GPT-5.1 (2026) for Developers: A Complete, Practical Guide to the gpt-5.1 API, Migration, and Best Practices, which covers the enterprise considerations, security implications, and integration pathways relevant to this discussion.

API endpoint changes and compatibility matrix

In 2024–2025 OpenAI consolidated endpoints around the /v1/responses (chat-first) and /v2 (newer) paradigms. For 2026, migration of GPT-5.4 to the new model family means you must update some calls and parameters depending on how your stack interacts with the API.

Key changes you must be aware of:

• Model name change: requests referencing “gpt-5.4” must be updated to the appropriate new model name (e.g., “gpt-5.5”, “gpt-5.5-pro”, “gpt-5.6-terra”).
• Endpoint consolidation: if you use legacy /v1/completions or engine-specific endpoints, migrate to /v1/responses or /v2/responses depending on SDK and feature needs.
• Streaming protocol differences: the streaming payload format for the new models uses enriched delta events and may include deterministic event IDs for traceability. Update streaming parsers accordingly.
• Function calling compatibility: parameter signature for automatic function calling remains compatible in GPT-5.5 but 5.6 variants introduce structured/typed output options (enforce_schema parameter).

Compatibility matrix (endpoint, parameter, behavior)

Example: migration mapping for common endpoints

• Legacy: POST /v1/engines/gpt-5.4/completions → New: POST /v1/responses { “model”: “gpt-5.5”, “input”: … }
• Legacy streaming: wss over /v1/engines/… → New streaming: Event stream over /v1/responses?stream=true
• Legacy function calling: chat.completions function interface → New: responses with “tools” and enforce_schema for typed structured outputs

API-level compatibility table – parameter mapping

Prompt compatibility: what breaks and what works unchanged

Prompt compatibility is the practical heart of migration. Many applications rely on prompt engineering specifics, chain-of-thought behavior, and idiosyncratic completions of GPT-5.4. Below is an inventory of compatibility expectations and recommended mitigation strategies.

What generally works unchanged

• Basic chat-style prompts (instruction + context) — GPT-5.5 preserves conversational APIs and prompt layering semantics.
• Simple completions and summarization tasks — GPT-5.5 and GPT-5.6 Sol produce equivalent high-quality outputs with slightly different phrasing in some cases.
• Function calling basic usage — backward compatible in GPT-5.5; GPT-5.6 extends structured outputs and typed enforcement.
• Tokenization for common alphabets — backward-compatible, though tokenizer updates in GPT-5.6 may change token counts for non-Latin scripts.

What commonly breaks or changes

• Chain-of-thought dependencies that rely on very model-specific quirks — sometimes output order or micro-prompting shortcuts stop working. Use explicit step-by-step instructions rather than relying on emergent behavior.
• Prompts that exploit specific phrase completions or hallucination patterns — these may produce different but often better outputs; however, business logic depending on exact text tokens can fail.
• Token budget assumptions — GPT-5.6 tokenization changes can alter token counts and ordering in edge cases (e.g., long code blocks, binary attachments in multimodal prompts).
• Prompt-internal special tokens — if you relied on model-internal tokens or undocumented behavior, that will often break. Stick to documented control tokens and explicit stop sequences.

Mitigation: prompt hardening checklist

1. Parameterize prompts separately from logic. Keep templates in a versioned repository and tag the model used.
2. Replace reliance on emergent quirks with explicit instructive scaffolding (e.g., “Provide three numbered steps with concise bullets”).
3. For structured outputs, use the new enforce_schema (GPT-5.6) or function calling to ensure deterministic parsing.
4. Run automated regression tests (see “How to test your prompts” below) across representative prompt suites and score outputs using both semantic and token-level comparators.

Token pricing comparison (GPT-5.4 vs replacement models)

Pricing is a significant migration consideration. Below is a simplified pricing comparison representative of July 2026 official published prices. Pricing may vary by region and enterprise discounts; consult your billing portal for exact contract terms.

Notes:

• These prices are examples. Enterprise contracts can significantly alter these numbers via committed spend and custom pricing tiers.
• Compute-based pricing (for extended context windows in GPT-5.5 Pro and GPT-5.6) may be billed separately or include tiered scaling. Confirm with your account rep.

Performance benchmarks: speed, accuracy, reasoning quality

Benchmarks are essential to estimate operational cost and user experience changes. The numbers below summarize cross-model benchmarking performed on a representative suite of tasks: conversational throughput, MMLU-style knowledge recall, GSM8K arithmetic reasoning, multi-step planning tasks, and end-to-end response latency for 2k token outputs. Benchmarks were run across equivalent hardware cloud regions with identical request patterns to limit external variance (July 2026 internal benchmarks).

Interpretation:

• GPT-5.5 reduces latency and increases throughput relative to GPT-5.4 while improving accuracy modestly. It is the easiest migration path.
• GPT-5.5 Pro is designed for throughput-constrained environments and shows significant throughput gains. It costs more but sharply reduces p99 tail latency and increases concurrency headroom.
• GPT-5.6 Terra is slower on raw latency but improves accuracy and deterministic behavior — important for audit/regulatory use-cases or when consistency is mandatory.
• GPT-5.6 Luna includes multimodal overhead, which makes it more costly and slower per request, but it provides capabilities that older models cannot match (image + multi-document reasoning).

Benchmarking methodology (summary)

Use the following steps to reproduce or extend these benchmarks in your environment:

1. Assemble a representative sample of prompts (N ≥ 1,000) covering your common tasks: QA, summarization, code generation, classification, step-by-step reasoning.
2. For each model, run inference at controlled concurrency and measure p50/p90/p99 latency, throughput, and the accuracy metrics (e.g., MMLU, BLEU, ROUGE, custom business metrics).
3. When measuring deterministic features, enable deterministic mode in Terra by setting enforce_schema or temperature = 0 and compare token-level variety across runs.
4. Control for network variability by running in the same cloud region and repeating batches to compute confidence intervals.

Step-by-step migration checklist for API users

This checklist is a prescriptive, practical sequence to safely migrate production systems. Follow it in order and ensure you have adequate rollback plans and monitoring at each stage.

1. Inventory all GPT-5.4 usages
   • Search codebases and infra config for “gpt-5.4” references (API clients, environment variables, orchestration templates, function call descriptors).
   • List pipelines that indirectly depend on GPT-5.4 such as cached analysis or scheduled batch jobs.
2. Classify workloads
   • Label workload types: low-latency conversational, batch summarization, high-QPS indexing, multimodal, compliance-sensitive, fine-tuned models.
   • Map each workload to candidate replacement models using the decision matrix below.
3. Prepare a test harness
   • Create a prompt test suite that captures representative and edge-case prompts (include negative tests that guard against hallucinations and bad format outputs).
   • Implement automated regression tests that compare outputs across GPT-5.4 and target models using semantic similarity metrics (embeddings cosine similarity), token-level differences, and task-specific accuracy scores.
4. Update SDKs and endpoints
   • Upgrade to the latest OpenAI SDK or standardize on a stable HTTP client with versioned API calls to /v1/responses or /v2/responses as appropriate.
   • Replace model names programmatically using feature flags or configuration toggles.
5. Dry-run tests
   • Run your test suite against the replacement models, collect metrics, and analyze deltas. Use A/B testing to compare live results for a small percent of production traffic if feasible.
6. Update prompt templates
   • Identify prompts that fail regression and refactor them to be robust (use explicit instructions, schema enforcement, or function calling).
   • Lock prompt templates in a versioned store for auditing (e.g., git, artifact repo).
7. Fine-tune migration
   • Export fine-tuning datasets and re-train on GPT-5.5 or GPT-5.6 Terra using OpenAI migration tooling. Validate performance vs original fine-tune using the same test harness.
8. Monitoring & observability
   • Enable detailed model-name tagging in logs, capture p50/p95 p99 latencies, input/output token counts, and semantic drift metrics (embedding-based similarity over time).
   • Set alerts for increases in error rate, unexpected spikes in token usage, and significant semantic drift.
9. Gradual rollout
   • Rollout using feature flags: 1% → 5% → 25% → 100% over multiple days while observing KPIs.
   • Maintain a fallback to GPT-5.5 (or previous stable replacement) if you test against 5.6 and find regressions.
10. Final switch and decommissioning
    • Transition all traffic off GPT-5.4 before July 23 and verify registry audits and that no 410s are present in error aggregates.
    • Export logs and fine-tune metadata per your retention policy. Delete local references to avoid accidental calls after the cutoff.

Quick API migration code examples

Below are sample code snippets showing common migrations: legacy completions → new responses-based API, and streaming changes.

// Legacy (GPT-5.4) - pseudo-curl for completions (legacy)
curl https://api.openai.com/v1/engines/gpt-5.4/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Summarize the product update in 3 bullets.",
    "max_tokens": 200,
    "temperature": 0.7
  }'

// New (GPT-5.5) - responses-based API (curl example)
curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "input": "Summarize the product update in 3 bullets.",
    "max_output_tokens": 200,
    "temperature": 0.7
  }'

// Python example using requests and simple streaming handler
import requests
import sys

API_KEY = "REPLACE"
url = "https://api.openai.com/v1/responses?stream=true"
headers = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

payload = {
  "model": "gpt-5.5-pro",
  "input": "Explain how to migrate from GPT-5.4 to GPT-5.5 in 5 steps.",
  "max_output_tokens": 300,
  "temperature": 0.2
}

with requests.post(url, headers=headers, json=payload, stream=True) as r:
    for line in r.iter_lines():
        if line:
            # new streaming delta format: parse JSON and handle 'delta' fields
            data = line.decode("utf-8")
            print(data)
            sys.stdout.flush()

// JavaScript fetch streaming example
const res = await fetch("https://api.openai.com/v1/responses?stream=true", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "gpt-5.5",
    input: "Translate to French: 'We are migrating off GPT-5.4'",
    max_output_tokens: 60
  })
});

const reader = res.body.getReader();
const decoder = new TextDecoder();
let buffer = "";

while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });
  // parse event deltas in buffer and flush completed segments
}

[h3]Note on function-calling and structured outputs[/h3]

GPT-5.6 models introduce enforce_schema and typed outputs. If you previously used ad-hoc text parsing, consider switching to structured outputs and schema enforcement for robust parsing.

Step-by-step migration checklist for ChatGPT web/app users

End-users and admins using the ChatGPT web or app interfaces will have a different migration flow. The cloud admin center provides controls for pre-selecting fallback models for assistants and exporting chats. Below are the concrete steps for accounts and admins.

1. Identify custom assistants and pinned models

   In Teams or Enterprise Admin Center, list all assistants or integrations explicitly bound to GPT-5.4. Export assistant configs for migration records.

2. Export conversation histories

   Export chats that must be preserved for audit. Use the Admin export tools to dump conversation transcripts before the July 23 cutoff. Note that exported data will include model_name metadata which aids post-migration audits.

3. Select fallback models

   For each assistant, choose a fallback: GPT-5.5 (default), GPT-5.6 Terra (audit/reasoning), or GPT-5.6 Luna (multimodal). Set the fallback in the assistant settings.

4. Test assistant behavior

   Use the assistant test console in the Admin Center to run representative prompts. Pay attention to differences in generated content and update assistant system messages or guidance accordingly.

5. Notify users

   Send communications to end-users about model change and expected differences, including links to updated prompt guidance and how to report regressions.

6. Monitor post-migration feedback

   Track user feedback and support tickets for model regressions. If an assistant exhibits substantial differences, change its model selection or update its system prompt to restore prior behavior.

How to test your prompts against new models before the deadline

Testing must be disciplined, automated, and cover functional correctness, semantic equivalence, and business KPIs. Below are concrete steps and sample scripts to validate prompts. The strategy uses A/B testing (side-by-side runs), semantic similarity via embeddings, and tolerances for acceptable deltas.

Testing approach

1. Assemble a test corpus of prompts representing 90–95% traffic for coverage. Include edge cases and malicious or adversarial prompts your app expects to handle.
2. Define scoring metrics: task accuracy (e.g., QA exact match), semantic similarity (embedding cosine ≥ 0.92), token length delta (±10% tolerance), and safety score (no prohibited content).
3. Run parallel inference on GPT-5.4 (historical baseline) and the candidate model(s).
4. Aggregate deltas and classify failures into minor, major, and critical. Plan mitigations accordingly.

Automated regression test script (Python pseudocode)

"""
Simple regression test harness:
- Runs a set of prompts against GPT-5.4 (baseline) and GPT-5.5
- Computes embedding cosine similarity and a simple text-diff threshold
- Flags regressions if similarity below threshold or length/format changes
"""
import requests
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

API_KEY = "REPLACE"
BASE_URL = "https://api.openai.com/v1/responses"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

prompts = [
  "Summarize this legal clause: ",
  "Write SQL to extract users with inactive subscriptions.",
  # ... add 100s more representative prompts
]

def get_response(model, prompt):
    r = requests.post(BASE_URL, headers=HEADERS, json={
        "model": model, "input": prompt, "max_output_tokens": 200
    })
    r.raise_for_status()
    return r.json()["output_text"]

def get_embedding(text):
    r = requests.post("https://api.openai.com/v1/embeddings", headers=HEADERS, json={
        "model": "text-embedding-5",
        "input": text
    })
    r.raise_for_status()
    return np.array(r.json()["data"][0]["embedding"])

threshold = 0.92
results = []

for prompt in prompts:
    base_out = get_response("gpt-5.4", prompt)
    new_out = get_response("gpt-5.5", prompt)
    emb_base = get_embedding(base_out)
    emb_new = get_embedding(new_out)
    sim = cosine_similarity([emb_base], [emb_new])[0][0]
    len_ratio = len(new_out) / max(1, len(base_out))
    ok = sim >= threshold and 0.9 <= len_ratio <= 1.1
    results.append({"prompt": prompt, "sim": sim, "len_ratio": len_ratio, "ok": ok})

# Summarize failures
failures = [r for r in results if not r["ok"]]
print(f"{len(failures)} failures out of {len(prompts)}")
for f in failures[:20]:
    print(f)

Use domain-specific validators where possible. For code generation, run outputs through linters/tests. For SQL, run against a read-only test DB and verify semantics. For legal text summaries, have human QA sample outputs for compliance.

Enterprise considerations: compliance, audit trails, versioning

Enterprises face additional constraints. Model migration touches regulatory, security, and audit boundaries. Below is a prioritized checklist and recommended practices for enterprise-grade migration:

1. Model provenance and versioning

• Log the model name, model fingerprint (OpenAI attaches a model_fingerprint in responses), and request signature for every inference. Persist these in your observability database.
• Use a central config store for model selection per environment (dev/stage/prod) and tag deployments with the model version used.

2. Audit trails

• Retain request/response metadata for a retention period aligned with compliance needs. Avoid storing raw PII unless permitted by policy—use redaction/PII removal steps.
• Export conversation logs and assistant configurations before GPT-5.4 cutover for legal or compliance review.

3. Deterministic modes & deterministic logging

• When determinism is required, use GPT-5.6 Terra deterministic modes and capture seeds and model fingerprint within logs to prove reproducibility.
• Record enforce_schema and function call outputs as structured logs to enable automated auditing.

4. Data residency and residency controls

• If you have regional data residency requirements, confirm that the target model’s compute region aligns with your contract. Some model variants (5.5 Pro, 5.6 Terra) may be restricted to specific regions for enterprise privacy reasons.

5. Contractual and legal obligations

• Check your data processing addendums (DPAs) and sections about model upgrades and deprecation. OpenAI may provide migration credits or transitional support—document any agreed allowances and timelines.

6. Risk management

• Run a risk assessment specifically addressing model-induced behavior changes (hallucinations, differences in refusal behavior, or different safety filters).
• Update your incident response plan to include a model-change rollback if critical issues appear post-migration.

Common migration pitfalls and how to avoid them

Below are recurring mistakes organizations make and concrete ways to avoid them during model migrations.

Pitfall 1 — Not inventorying indirect dependencies

Many teams miss integrations like scheduled batch jobs, ETL pipelines, or third-party connectors that call the model. Conduct a codebase-wide grep and dependency analysis.

Pitfall 2 — Hard-coded prompts in UI code

When prompts are embedded directly in frontend code, changes require a full release cycle. Move prompts into a configurable, versioned prompts store ahead of migration.

Pitfall 3 — Not testing negative/adversarial prompts

Model changes can alter refusal behaviors. Run a negative prompt test suite and ensure safety filters are consistent with policy.

Pitfall 4 — Overlooking token budget changes

Tokenization differences can cause budget overruns. Re-run tokenization and cost projections on a sample traffic day to adjust throttles and budgets.

Pitfall 5 — Assuming 1:1 functional equivalence

Even small phrasing changes can break downstream parsers. Use structured outputs and schema enforcement where possible and prefer typed function outputs over fragile parsing.

Decision matrix: choosing the right replacement model

The table below helps you choose a model based on prioritized requirements. Each row is a decision question with recommended model(s).

How to test prompts and run canary rollouts before July 23

Canary rollouts and gradual traffic shifting allow you to measure real-world impact. Use the following practical plan for canary rollouts:

1. Create feature flags — New model selection must be toggled via configuration flags that you can adjust without code deploys.
2. Small sample traffic — Start at 0.5–1% of production traffic. Monitor latency, error rates, token consumption, and task-level KPIs.
3. Compare user satisfaction — Instrument feedback prompts or NPS triggers where possible; track changes across canary and control cohorts.
4. Time-based regression windows — Run canary for a minimum of 24–72 hours capturing different traffic patterns (peak and off-peak) to observe tail behaviors.
5. Define rollback triggers — Predefine thresholds for errors, token usage, or task-specific accuracy deltas that automatically roll back the canary if exceeded.

Fine-tune migration and retraining guidance

Many teams used fine-tuned GPT-5.4 variants in production. Since OpenAI blocks new fine-tunes against GPT-5.4 after the cutoff, you must migrate fine-tunes proactively.

Steps to migrate fine-tunes

1. Export training datasets and relevant evaluation sets.
2. Run baseline evaluation of current fine-tune on GPT-5.4 (final snapshot) and measure baseline metrics.
3. Retrain equivalent fine-tune on GPT-5.5 or GPT-5.6 Terra depending on your needs.
4. Compare and iterate: evaluate using the same dataset and production tests. Use early stopping thresholds and human sampling to certify alignment with quality goals.
5. Deploy new fine-tuned model behind feature flags and monitor for drift.

Practical considerations

• Some hyperparameters and loss scaling may need retuning due to base-model behavioral differences.
• When migrating to GPT-5.6 Terra with deterministic modes, adjust training labels to account for stricter output constraints.

Operational checklist for post-migration validation

1. Verify no API calls to gpt-5.4 exist in logs.
2. Confirm billing accounts have no active gpt-5.4 usage and reconcile invoices.
3. Document changes: prompts, model selection, decision rationale, and test results for internal audits.
4. Run a "migration post-mortem" with stakeholders including product, legal, compliance, and engineering to document lessons and retained risk items.

Common migration scenarios and typical fixes

Scenario: Summarization style shift

Problem: GPT-5.5 gives shorter summaries than GPT-5.4. Fix: adjust instruction to "Provide four bullet points, each 12–20 words, focusing on X, Y, Z" and use stop_sequences to enforce formatting.

Scenario: Code generation formatting changes

Problem: Generated code uses different stylistic choices causing tests to fail (e.g., single quotes vs double quotes). Fix: use a post-generation formatter (prettier/black) and set a "style guide" instruction in system prompt.

Scenario: Differential refusal behavior

Problem: New model refuses certain content previously accepted, breaking workflows. Fix: evaluate safety policy differences; if acceptable, modify the system prompt with allowed exceptions verified by legal, or route those requests through an approval pipeline.

Appendix: Additional migration resources and tooling

• OpenAI Migration Tooling (console-assisted) — Export and auto-migrate fine-tunes.
• Prompt version control examples — templates for structuring prompt repositories.
• Regression testing frameworks — examples of scoring harnesses and embedding-based similarity measurements.

FAQ

Q1: Will requests to gpt-5.4 be served after July 23 if I have an enterprise contract?

OpenAI's stated policy is that gpt-5.4 will stop accepting inference requests for all customers on July 23, 2026. Enterprise customers should consult their account rep for migration assistance or any temporary exceptions; however, they should not plan to keep production traffic on gpt-5.4 beyond the cutoff. Migration assistance and credits may be offered as part of enterprise transition programs, but these are negotiated case-by-case.

Q2: Are GPT-5.4 fine-tunes recoverable after retirement?

You can read metadata and exported training assets for 30 days after retirement. Existing fine-tuned models that are bound to the gpt-5.4 base become read-only and will not accept new fine-tune jobs. To operationalize fine-tuned capabilities past retirement, export the dataset and retrain on a supported replacement model (GPT-5.5 or GPT-5.6 Terra). OpenAI provides migration tooling and best-practice guides to accelerate this step.

Q3: How much effort should I expect for migration?

Effort varies with use-case complexity. Simple conversational apps with templated prompts can often switch to GPT-5.5 with minimal changes in days. Complex pipelines with many fine-tunes, multimodal inputs, or tightly coupled parsing logic may require 2–8 weeks including testing and compliance checks. Follow the playbook checklists and automate regression testing to reduce manual effort.

Q4: Will my token costs change after migrating?

Possibly. Replacement models have different per-token prices and may tokenize some inputs differently. Run cost projection tests using representative traffic to measure projected monthly costs. If cost is a major concern, consider GPT-5.6 Sol for large-volume inference due to its lower per-token cost, or negotiate an enterprise pricing plan.

Q5: Should I migrate to GPT-5.5 or jump to GPT-5.6 Terra/Luna?

Choose GPT-5.5 for minimal friction and cost/latency parity to GPT-5.4. Choose GPT-5.6 Terra when deterministic, audited reasoning is required, or when compliance requires reproducible outputs. Choose GPT-5.6 Luna if you need multimodal capabilities (images + text) or fusion across multiple documents. For many organizations, the practical plan is to migrate the majority to GPT-5.5, then evaluate targeted workloads that would benefit from 5.6 variants.

Q6: What happens to my conversation history in ChatGPT that used GPT-5.4?

Conversation transcripts remain accessible in ChatGPT and Admin exports for a limited period and will include model_name metadata. Administrators should export required histories for archival or compliance prior to the retention window closing. After the retention window, the platform will keep user-visible transcripts but will internally replace references to the deprecated model with the selected fallback model identifier.

Q7: Do I need to retrain all my fine-tunes?

Yes — to continue using fine-tuned behavior in production you should retrain your fine-tune datasets on a supported base model (GPT-5.5 or GPT-5.6). Some single-shot or few-shot prompt engineering that relied on the base model’s quirks may be recoverable with prompt tuning alone, but for guaranteed parity retraining is recommended.

Q8: How do I capture and prove model provenance for audit?

Always store the model name, model_fingerprint header (provided in responses), request timestamp, parameters, and a hashed copy of the prompt and output in a secure audit log. Use deterministic modes (GPT-5.6 Terra) when possible for critical decisions, and store seeds/flags. Maintain a migration artifact that documents which prompts were updated, when, and under which test results the change was approved.

Final recommendations and migration timeline checklist

To finish on time and minimize risk, use this condensed timeline and map it to the detailed checklists above:

1. Now (ASAP): Inventory, classify workloads, and set up testing harness.
2. 2–3 weeks before July 23: Start migration of low-risk systems to GPT-5.5 and run canaries.
3. 1–2 weeks before July 23: Migrate fine-tunes, run full regression suites, and onboard enterprise compliance sign-offs.
4. 72 hours before July 23: Complete exports of logs and conversation history required for records retention.
5. 24 hours before July 23: Stop any scheduled jobs referencing GPT-5.4 and confirm that all production traffic has toggled to replacement models.
6. July 23, 2026: Confirm no GPT-5.4 traffic; verify alerts and audit logs.
7. Post-migration (1–4 weeks): Monitor KPIs, collect user feedback, and iterate on prompt/system changes.

Migration is as much a governance and testing exercise as it is a technical update. Use versioned prompts, automated testing, observability, and a staged rollout to reduce risk. The replacement model family (GPT-5.5 and GPT-5.6 variants) provides a range of options for balancing cost, throughput, and reasoning guarantees — choose deliberately based on your workload classification and compliance posture.

Closing notes

Retirement of GPT-5.4 is an opportunity to upgrade and rationalize model usage across your organization. Use the migration to improve repeatability (versioned prompts and structured outputs), strengthen your observability, and align on long-term costs and compliance structures. If you require vendor support, reach out to your OpenAI account representative for migration tooling, fine-tune migration assistance, and potential transitional credits. Execute with clear milestones, automated validation, and a staged rollout to minimize customer and business disruption.

For further internal resources, review:

Practitioners looking to extend these approaches will find valuable context in our detailed coverage of The Complete Guide to GPT-5.6 Luna for High-Volume Production — Classification, Routing, Summarization, and Cost Optimization at Scale, which explores advanced configuration options and troubleshooting methodologies for complex deployments.

for prompt hardening,

For a deeper exploration of OpenAI API tutorial, our comprehensive guide on How OpenAI’s $30 Billion Revenue Target Is Reshaping the AI Industry: From Research Lab to Enterprise Platform provides detailed walkthroughs, practical examples, and expert recommendations that complement the strategies discussed in this section.

for endpoint migration examples,

Teams implementing these workflows will benefit from understanding the foundational concepts covered in our detailed analysis of How Enterprise AI Governance Is Evolving in 2026: From Microsoft Purview to OpenAI’s Built-In Compliance Tools, which examines the technical architecture and best practices for production deployments.

for compliance frameworks, and

The techniques described above build upon the principles outlined in our in-depth tutorial on What’s New in GPT-5.1 (2026) for Developers: A Complete, Practical Guide to the gpt-5.1 API, Migration, and Best Practices, where we examine real-world implementation patterns and performance optimization strategies.

for retraining workflows.