OpenAI → Claude Migration: The Real Cost Delta (2026)

**1. Per-token price**. The headline number from the table above. Useful only as the starting point. For Sonnet 4.6 vs gpt-5.4 the delta is small (+20% input / 0% output). For Haiku 4.5 vs gpt-5-mini it's brutal (+220% / +100%). For Opus 4.7 vs gpt-5.5 it's structurally indefensible outside frontier reasoning workloads (+1,100% / +650%). Anchor on this only for sanity — the next five variables can swing the final bill by 3-5x in either direction.

**2. Output-length multiplier**. The single most-ignored variable. By our internal evals across customer-support, summarization, and code-generation prompts, Claude Sonnet 4.6 produces 20-40% longer outputs than gpt-5.4 on identical instructions. Claude is trained to over-explain, hedge, and structure with headers; GPT is trained to be terser. Multiply your projected Claude output token count by 1.2-1.4x before you trust any cost projection. On a workload that's 80% output cost, a 1.3x verbosity multiplier eats a 30% input-side cache discount entirely.

**3. Cache discount differential**. Anthropic prompt caching gives 90% off cached input tokens (5-minute default TTL, 1-hour TTL available at 2x write cost). OpenAI's automated cache gives 50% off cached tokens with no TTL controls. For any workload with a stable system prompt or stable retrieval context, this is a 5x advantage to Anthropic on the cached portion. The breakeven where caching flips a Claude-loses comparison to a Claude-wins comparison is roughly: when >60% of input tokens are cacheable and reused >2x within the TTL window.

**4. Batch discount differential**. Both providers offer batch mode at ~50% off list price for 24-hour-tolerant workloads. The differential is small (both ~50%) but Anthropic's batch API throughput limits are tighter, and certain models (Opus 4.7) gate batch behind enterprise tiers. If you're already on OpenAI batch, the move to Anthropic batch may require throughput renegotiation.

**5. Prompt-rewrite tax**. GPT prompts written without XML structuring, without explicit response-format anchors, and without cache-prefix discipline under-deliver on Claude — typically 10-25% lower quality on the same task by internal eval. Rewriting 50 production prompts to Claude-native conventions is ~25 engineer-hours = $3-5k internal cost. This is one-time but unavoidable; budget it.

**6. Latency and retry tax**. Anthropic Sonnet 4.6 median TTFT is 800ms-1.2s; Haiku 4.5 is 400-600ms. OpenAI gpt-5.4 is 400-700ms; gpt-5-mini is 200-400ms. If your service has a strict p99 latency SLA, Anthropic's higher TTFT may force you to increase retry budgets, fallback to faster models, or accept higher timeout rates — each of which has a cost.

**Workload shape**: 1,000,000 inbound support tickets per month, classified into one of 18 intent categories. Each ticket: 250 input tokens (system prompt + ticket body) + 75 output tokens (JSON {category, confidence, reason}). System prompt is ~180 tokens of the 250 input, fully cacheable; the remaining 70 tokens are per-ticket ticket body content.

**Current state — gpt-5-mini**: per-call cost = (250 input × $0.25/1M) + (75 output × $2/1M) = $0.0000625 + $0.00015 = $0.0002125. Monthly = $0.0002125 × 1,000,000 = **$212.50/month**. With OpenAI's automatic 50% cache discount on the stable 180-token system prompt, the input portion drops by ~36% (180/250 cached × 50% off), bringing the bill to roughly $190/month.

**Migration to Haiku 4.5**: per-call cost = (250 input × $0.80/1M) + (75 output × $4/1M) = $0.0002 + $0.0003 = $0.0005. Monthly = $0.0005 × 1,000,000 = **$500/month**. With Anthropic's 90% cache discount on the same 180-token prefix, input drops sharply: cached input cost becomes (180 × $0.80 × 0.10) + (70 × $0.80) = $0.0000144 + $0.000056 = $0.0000704 input per call. Output stays at $0.0003. New per-call: $0.0003704. Monthly: $370.40. Add output-verbosity multiplier (1.3x for an over-helpful 'reason' field): output portion grows from $0.0003 to $0.00039, total $0.0004604, monthly **$460.40**.

**Net delta**: $190 → $460 = **+142% migration cost** for the same workload. The cache discount helps but cannot overcome the 3x per-token gap on this short-input/short-output shape. Verdict: this is the canonical case for *not* migrating. Keep classification on gpt-5-mini (or gpt-5-nano if 18-category accuracy holds). If Claude is mandated for the product, route classification specifically to gpt-5-mini via OpenAI while the rest of the stack runs Anthropic — multi-provider is cheaper than principle here.

**Workload shape**: 10,000 documents summarized per month. Each doc: 25,000 input tokens (document body + system prompt + instructions) + 4,000 output tokens (structured summary with sections, bullets, key quotes). System prompt + instructions = 5,000 tokens of the 25,000 input, fully stable. Documents are mostly unique but ~20,000 tokens of the input is a stable retrieval context (style guide + exemplar summaries + taxonomy) that is reused across calls.

**Current state — gpt-5.4**: per-call cost = (25,000 × $2.50/1M) + (4,000 × $15/1M) = $0.0625 + $0.060 = $0.1225. Monthly = $0.1225 × 10,000 = **$1,225/month**. With OpenAI's 50% cache discount on the 5,000-token system prompt (the 20,000 retrieval context only caches if it's literally repeated, which here it is): cached portion = 25,000 × 50% × $2.50/1M = $0.03125 saved per call, dropping total to **$912.50/month**.

**Migration to Sonnet 4.6**: per-call cost = (25,000 × $3/1M) + (4,000 × $15/1M) = $0.075 + $0.060 = $0.135. Monthly = **$1,350/month**. Now apply Anthropic's 90% cache discount on the 25,000 cacheable tokens: cached input = 25,000 × $3/1M × 0.10 = $0.0075 per call. Output stays $0.060. Per-call total = $0.0675, monthly = **$675**. Apply output-verbosity multiplier (1.25x on long-form summaries — Claude adds section headers, expanded bullets): output rises from $0.060 to $0.075, per-call $0.0825, monthly **$825**.

**Net delta**: $912.50 → $825 = **-10% migration savings**. Claude wins this one on cache leverage — and if your retrieval context is even more cacheable (say 22,000 of 25,000 tokens), the win grows to -25% to -35%. This is the canonical case for migrating: long stable prefixes, long output, medium volume. The cache discount differential (90% vs 50%) does the load-bearing work; without it Sonnet would lose this comparison by +10%.

**Workload shape**: 100,000 agent runs per month. Each run: an orchestrator model picks one of 12 tools, dispatches to a worker model, evaluates the result, and decides to continue or finish. Average 8 tool turns per run. Orchestrator turn: 3,000 input + 500 output tokens. Worker turn: 1,000 input + 300 output tokens. The orchestrator system prompt + tool schemas = 2,500 of the 3,000 input tokens, stable across all turns within a run.

**Current state — OpenAI (gpt-5.5 orchestrator + gpt-5-mini worker)**: orchestrator per-turn = (3,000 × $1.25/1M) + (500 × $10/1M) = $0.00375 + $0.005 = $0.00875. Worker per-turn = (1,000 × $0.25/1M) + (300 × $2/1M) = $0.00025 + $0.0006 = $0.00085. Per-run (8 turns each): orchestrator $0.07 + worker $0.0068 = $0.0768. Monthly = $0.0768 × 100,000 = **$7,680/month**. Add OpenAI cache discount on the 2,500-token orchestrator prefix (cached across the 8 within-run turns): saves ~$0.0156 per run, dropping to roughly **$6,120/month**.

**Migration to Anthropic (Opus 4.7 orchestrator + Haiku 4.5 worker)**: orchestrator per-turn = (3,000 × $15/1M) + (500 × $75/1M) = $0.045 + $0.0375 = $0.0825. Worker per-turn = (1,000 × $0.80/1M) + (300 × $4/1M) = $0.0008 + $0.0012 = $0.002. Per-run: orchestrator $0.66 + worker $0.016 = $0.676. Monthly = **$67,600/month**. That is the headline disaster number — Opus 4.7 priced as a default orchestrator is roughly 11x the OpenAI bill.

**With Anthropic optimizations**: apply 90% cache discount on the 2,500-token orchestrator prefix across all 8 turns (cached writes once, reads 7 times): saves ~$0.236 per run. Switch the orchestrator from Opus 4.7 to Sonnet 4.6 with extended thinking gated to only the first turn (where tool selection happens): Sonnet at $3/$15 vs Opus at $15/$75 cuts orchestrator cost ~5x. Net: per-run drops from $0.676 to roughly $0.14, monthly to **$14,000**. Still ~2.3x the OpenAI bill, but the gap closes from 11x to 2.3x once you do the work.

**Verdict**: comparable order of magnitude once you optimize, but OpenAI structurally wins on agent loops because gpt-5.5's $1.25/$10 is a frontier-quality orchestrator at sub-Sonnet prices. If your agent needs Opus-grade reasoning specifically, migrate. Otherwise, OpenAI is the cheaper agent platform in 2026 — and this is the largest single category where the migration loses.

Anthropic prompt caching: 90% off cached input reads, 25% premium on the cache write, 5-minute default TTL (1-hour TTL available at 2x write cost since the Q4 2025 update). OpenAI automated caching: 50% off cached input tokens, no TTL controls, no write premium, cached/uncached split surfaced in API response metadata.

Worked math. Take a 10,000-token system prompt, called 1,000 times in a sustained burst (within TTL). OpenAI cost: (10,000 × 1,000 calls × $2.50/1M) × 0.50 (50% off) = $12.50. Anthropic Sonnet 4.6 cost: write cost = 10,000 × $3/1M × 1.25 (25% premium) = $0.0375 one-time + read cost = (10,000 × 999 calls × $3/1M) × 0.10 (90% off) = $3.00. Total = $3.04. The Anthropic bill is roughly 4x cheaper on the cached portion despite Sonnet's headline price being 20% higher than gpt-5.4's. This is the single largest reason Claude migration math turns positive on stable-prefix workloads.

Where caching does NOT help: stateless one-shot prompts with no stable prefix, low-frequency workloads where TTL expires between calls, prompts where the variable content sits in the middle of the prompt (cache only works on prefix), and workloads where prompt structure varies meaningfully across calls. If your traffic looks like 'one call every 30 seconds, totally different prompt each time', the cache discount disappears for both providers and you're back to comparing list prices — where OpenAI wins.

Practical placement: put your system prompt + tool schemas + few-shot exemplars + stable retrieval context at the *front* of every request. Put per-call variable content (user input, current retrieval result, dynamic data) at the *end*. On Anthropic, explicitly mark the prefix end with a `cache_control` block (the SDK exposes this on each content block). On OpenAI, caching is automatic — but only on the literal prefix, so prefix discipline matters there too.

Internal eval: we ran 200 identical prompts across customer-support replies, summarization, classification rationales, and code generation through Sonnet 4.6 and gpt-5.4 with temperature 0.7. Median Claude output length was 1.32x the GPT output length. On structured-summary tasks specifically, the multiplier rose to 1.40x. On classification (JSON-only output), the multiplier was 1.05x — close to parity, because the JSON schema constrains output length structurally.

Why: Anthropic's RLHF training preference rewards thoroughness, structured headers, explicit caveats, and 'and finally' wrap-up paragraphs. OpenAI's RLHF preference is terser, especially since the 5.x generation explicitly optimized for token efficiency under product-economics pressure. Neither is wrong — they're trained for different default user experiences.

Mitigation: write the system prompt explicitly for concision. 'Respond in 3 sentences or fewer. No introductory paragraphs. No closing summary.' Anthropic models *will* follow this instruction, but you have to give it; the default behavior is verbose. A well-tuned concise system prompt closes the verbosity gap to ~1.10-1.15x, which is within budget for most workloads. Without that prompt discipline, factor 1.3x into all cost projections.

Second-order effect: Claude's longer outputs sometimes deliver real value (more useful summaries, more diagnostic error explanations, more thorough code review comments). Pure cost-per-token thinking misses this. The right framing is cost-per-resolved-task, not cost-per-token — and on cost-per-task Claude sometimes wins even at a verbosity premium.

Lift-and-shift does not work. GPT prompts written in Markdown headers, with response-format instructions in plain English, with stable context interspersed with user content, will under-deliver on Claude by 10-25% on eval quality. Claude prompts written for the Anthropic conventions — XML tags around structural sections, system+user split, cache-anchor placement, response-format JSON schema (now a first-class Anthropic SDK feature as of Q1 2026) — deliver the quality Anthropic's pricing assumes.

Rewrite checklist per prompt: (1) move all instructions, schemas, and exemplars into the system role; user role contains only the current call's variable input. (2) Wrap each structural section in XML tags (`<instructions>`, `<context>`, `<exemplars>`, `<format>`). (3) Place stable content at the front; put `cache_control: {type: 'ephemeral'}` on the boundary between stable and variable content. (4) If you want structured output, use the `response_format` JSON schema parameter — do not rely on 'respond in JSON' in the prompt body. (5) Convert OpenAI tool definitions to Anthropic tool schemas (close but not identical — `input_schema` vs `parameters`, no `strict` flag, different output handling).

Time budget per non-trivial prompt: ~30 minutes for the conversion, ~30 minutes for eval against a hold-out set, ~30 minutes for iteration when eval flags regressions. Call it 90 minutes per prompt at the high end, 30 at the low end. For a typical mid-sized SaaS with 50 production prompts: 25-75 engineer-hours = $3-12k internal cost at standard fully-loaded rates. Larger orgs with 200+ prompts can budget $20-40k.

This tax is one-time but real, and it's the line item most often missing from migration business cases. If your CFO sees the per-token table and approves the migration without budgeting engineering hours, the project goes over budget in week one.

Median time-to-first-token (TTFT), measured across June 2026 production traffic by the third-party Helicone benchmarks and our own probes: Claude Sonnet 4.6 800ms-1.2s. Claude Haiku 4.5 400-600ms. Claude Opus 4.7 1.5-2.5s. OpenAI gpt-5.4 400-700ms. OpenAI gpt-5-mini 200-400ms. OpenAI gpt-5.5 600-1s. OpenAI gpt-5-nano 150-300ms.

For chat UIs with streaming, TTFT delta of 300-500ms is noticeable but tolerable — users don't see a discrete time difference, just a slightly different 'thinking' feel. For voice agents where TTFT directly delays the assistant's first word, Anthropic's higher TTFT is meaningful — switching from gpt-5-mini to Haiku 4.5 adds 200-400ms to first-word latency, which voice product managers consistently flag as a regression.

For p99-SLA-bound services (a customer-facing API with a 2-second p99), Anthropic's higher TTFT plus longer outputs (which means longer total stream duration) can push p99 over the SLA when gpt-5-mini sat comfortably under it. Mitigation: increase the timeout budget, add a fast-fallback to a cheaper Anthropic model on timeout, or accept the SLA degradation. Each has a cost — either dollars (retry billing), engineering time (fallback logic), or user experience (slower service).

Empirical retry-rate observation: on a stable workload that retried 0.4% of OpenAI calls due to 429s or timeouts, the same workload on Anthropic retried 1.1% of calls in the first two weeks of migration. Anthropic's rate-limit behavior is more aggressive on burst traffic; you have to negotiate higher limits or smooth traffic with a queue. Both add cost not captured in the per-token table.

**Long-document workloads with stable retrieval context**. The 90% cache discount on 100k-200k cacheable prefixes dominates everything else. If you're sending the same 150k-token codebase or document corpus on every call, Anthropic is structurally cheaper than OpenAI by 40-70%, even before per-token price comparisons.

**200k+ context windows used in earnest**. Sonnet 4.6 and Opus 4.7 handle 200k input cleanly with the 1M-token context preview now in beta for select Opus customers. OpenAI's gpt-5.5 nominally supports 200k but degrades on long-context retrieval quality past ~120k by needle-in-haystack evals. If your workload actually uses the long context (not just declares it), Claude is the more cost-effective choice because it doesn't force you to chunk and run multiple calls.

**Multi-turn agents with stable system prompts and tool schemas**. The same cache leverage applies — if your agent's 5,000-token system prompt + tool schemas are cached across all turns of a multi-turn run, Anthropic's 90% read discount drops orchestrator-side input cost to near-zero. Combined with extended-thinking gating (only enable for tool-selection turns), this closes most of the agent-loop gap covered in worked example 4.

**Structured outputs with complex tool use**. Anthropic's tool-use ergonomics, especially with the parallel tool-call support added in Q4 2025 and the first-class JSON schema response_format added in Q1 2026, deliver fewer retries on malformed output. Lower retry rate = lower effective cost, even if list-price per call is higher. By internal eval, complex-tool-use workloads see 3-7% lower retry rates on Claude vs equivalent GPT setups.

**Workloads where output quality reduces downstream cost**. If a 1.3x-longer Claude output halves your human review time, the labor savings dwarf the API cost differential. This is especially true for customer-support reply generation, legal document drafting, and code-review comments — places where the API call cost is a rounding error compared to the human's hourly rate.

**High-volume short-input/short-output classification**. The gpt-5-nano $0.10/$0.80 floor is unmatched. Anthropic has no nano-tier model in 2026 and no public roadmap for one. If you classify 100M+ items per month and your prompt fits in a few hundred tokens, OpenAI wins by 3-8x and there is no Anthropic optimization that closes the gap.

**Real-time voice workloads**. gpt-5-mini's 200-400ms TTFT plus the native voice-modality models (gpt-4o-realtime and successors) make OpenAI the default for voice agents. Anthropic does not ship a native voice model; voice workflows on Claude require speech-to-text → Claude → text-to-speech pipelines that add 400-800ms of additional latency, on top of Claude's already-higher TTFT.

**Image generation**. OpenAI's gpt-image-2 at $0.04/image (standard) is meaningfully cheaper than the Anthropic + Google Imagen pipeline that Anthropic-stack teams typically resort to. If image gen is core to your product, OpenAI is structurally the better cost base.

**Anything needing the gpt-5-nano floor for screening before more expensive processing**. The classic 'cheap classifier as gatekeeper to expensive reasoning' pattern depends on having a sub-$0.20/$1 model for the screening step. Anthropic does not provide one, so Anthropic-only stacks waste money by routing screening traffic through Haiku 4.5 at 4-8x the cost it would have been on gpt-5-nano.

**Agent orchestrators that don't need Opus-grade reasoning**. As covered in worked example 4: gpt-5.5 at $1.25/$10 is the cheapest frontier-quality orchestrator on the market. If your agent loops don't specifically need Opus-grade nuance, OpenAI orchestrators with Haiku-grade Anthropic workers (a legitimate multi-provider pattern) hits the price-performance frontier.