GPT-5.6 Luna Price Cut: Migration Guide (2026) — New Pricing and How to Move High-Volume Work

On July 30, 2026, OpenAI dropped the price of GPT-5.6 Luna by 80% and GPT-5.6 Terra by 20%. That's not a rounding-error discount. If you run high-volume batch jobs, classification, or agent implementation steps, your per-task cost just fell off a cliff. The same day, OpenAI also swapped Priority Processing for a new Fast mode on GPT-5.6 Sol.

Price cuts are nice, but they only matter if you actually route work to the cheaper model. Most teams don't. They picked a default model months ago and never revisited it. This guide walks through the exact new numbers, when Luna is the right call, and how to migrate without breaking quality.

The New GPT-5.6 API Pricing (per 1M tokens, USD)

Here are the prices effective July 30, 2026. Sol stays put; the movement is all in the cheaper tiers.

The gap between Luna and Sol is now roughly 25x on both input and output. That's a huge lever. A workflow that blindly runs everything on Sol is leaving real money on the table if half those calls are well-specified, low-ambiguity tasks.

How the Three Tiers Compare

OpenAI's own framing is that you match intelligence to the outcome. Luna handles high-volume, well-defined work; Sol resolves ambiguity and plans. Here's the practical breakdown.

Note the context window is identical across all three at 1,050,000 tokens, so migrating down a tier doesn't cost you room for large documents or long agent histories. The tradeoff is reasoning depth, not context.

When to Migrate a Call to Luna

Don't dump everything onto Luna. Route by task shape. A quick rule I use:

• Move to Luna: the task is well-specified, the output format is fixed, and a wrong answer is cheap to catch. Think ticket classification, extracting fields from documents, running tests, applying a clearly-described code change.
• Keep on Sol: the task is ambiguous, the plan isn't obvious, or an error is expensive. Architecture decisions, root-cause debugging, anything where the model has to figure out what to do.
• Use Terra as the middle: when Luna feels a touch shallow but Sol is overkill.

The pattern OpenAI suggests for coding is a good template: use Sol to define the plan, then hand well-specified changes to Luna to implement, test, and evaluate. You pay Sol prices only for the thinking, not the typing.

Migration in Practice

The API surface is the same across tiers, so migration is usually a one-line model change plus a routing decision. Start with a plain curl call to confirm Luna works for your prompt:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-luna",
    "input": "Classify this support ticket. Return JSON with priority, owner, and next_action.\n\nTicket: Login page throws 500 after the latest deploy."
  }'

Python: route by task type

The cleanest migration isn't swapping one model for another everywhere. It's adding a router so each call lands on the right tier.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Map task types to tiers. Cheap work goes to Luna.
TIER = {
    "classify": "gpt-5.6-luna",
    "extract": "gpt-5.6-luna",
    "implement": "gpt-5.6-luna",
    "plan": "gpt-5.6-sol",
    "debug": "gpt-5.6-sol",
    "default": "gpt-5.6-terra",
}

def run(task_type: str, prompt: str) -> str:
    model = TIER.get(task_type, TIER["default"])
    resp = client.responses.create(model=model, input=prompt)
    return resp.output_text

# High-volume path now costs ~25x less than running it on Sol
print(run("classify", "Tag this review as positive, neutral, or negative: 'Fast and cheap.'"))

Node.js: same idea, with a Sol fallback

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function implementChange(spec) {
  // Try Luna first for well-specified work
  try {
    const r = await client.responses.create({
      model: "gpt-5.6-luna",
      input: `Apply exactly this change and return the full file:\n\n${spec}`,
    });
    return r.output_text;
  } catch (e) {
    // Escalate to Sol only if Luna fails
    const r = await client.responses.create({
      model: "gpt-5.6-sol",
      input: `Apply this change carefully:\n\n${spec}`,
    });
    return r.output_text;
  }
}

What About Fast Mode?

Fast mode replaces Priority Processing in the API. For GPT-5.6 Sol it runs up to 2.5 times faster than Standard processing at twice the price, with no change in intelligence. The nice part: it's backward compatible. If your existing requests already carry the priority tag, they'll automatically use Fast mode with no code change. In Codex it aligns with the /fast command.

Use it selectively. Fast mode doubles your Sol cost, so reserve it for user-facing calls where latency actually hurts, not background jobs where nobody's waiting.

Don't Skip the Cost Math

Before you migrate, model the actual savings. A workload doing 5 million input and 1 million output tokens a day looks very different across tiers:

That's $55/day versus $2.20/day for the exact same token volume. Over a month, roughly $1,650 versus $66. Obviously you won't move every call to Luna, but even shifting half your high-volume traffic down a tier pays for a lot of engineering time. Plug your own numbers into a cost calculator before committing.

FAQ

How much does GPT-5.6 Luna cost after the July 30, 2026 price cut?

As of July 30, 2026, GPT-5.6 Luna costs $0.20 per million input tokens and $1.20 per million output tokens through the OpenAI API, an 80% reduction from its previous price.

Did GPT-5.6 Terra and Sol prices change on July 30, 2026?

GPT-5.6 Terra dropped 20% to $2 per million input tokens and $12 per million output tokens. GPT-5.6 Sol pricing was unchanged, but Sol gained a new Fast mode that runs up to 2.5 times faster at twice the price.

What is GPT-5.6 Fast mode and does it replace Priority Processing?

Fast mode is a new API speed tier introduced on July 30, 2026 that replaces Priority Processing. For GPT-5.6 Sol it delivers up to 2.5 times faster responses than Standard at twice the price, with no change in intelligence. It's backward compatible, so requests tagged priority automatically use Fast mode.