GPT-6 Luna for High-Volume API Workloads: The Cost Math at Real Request Volumes

Every backend team has a list of jobs that would obviously be better with a language model and that nobody ever shipped. Classifying five million support events a day. Enriching a twelve million row catalog. Scoring every inbound webhook before it hits the queue. The reason is always the same: multiply a per request cost by your actual request count and the number stops being a rounding error.

GPT-6 Luna, announced on September 22, 2026, costs $0.10 per million input tokens and $0.50 per million output tokens, carries a 1,000,000 token context window, and applies a 90% discount to cached input reads. That is cheap enough to make several of those shelved jobs viable, and cheap enough to make people stop doing the arithmetic, which is how you end up explaining a five figure invoice.

So here is the arithmetic: three realistic workload shapes, the cost per million requests for each, and the three variables that decide your bill long before the sticker price does.

The rates you are working from

The cached read column for Sol and Luna is the published 90% discount applied to the input rate, not a separately published number. Anthropic publishes its cached read rate directly and also charges $5.00 per million to write the cache, which matters at volume: a workload with high prefix churn pays that write cost repeatedly.

One framing correction before the numbers. OpenAI describes Sol and Luna as 50% cheaper than GPT-5.6 promotional pricing. Promotional is OpenAI’s own word and it is doing real work: the comparison runs against a discounted rate, not the rate GPT-5.6 launched at. Against the GPT-5.6 Luna list price of $1 input and $6 output that our launch coverage documented, GPT-6 Luna is a 90% cut on input and 92% on output.

Workload A: high QPS classification

The shape most teams reach for first: a stable system prompt, tool schemas and a taxonomy, plus a small variable payload, returning a short structured verdict. Assume 1,500 tokens of stable prefix, 500 tokens of variable payload, 120 output tokens, and 5,000,000 requests per day.

At 5,000,000 requests a day that is $625 on Luna with a warm prefix, about $18,750 a month. The same traffic on Sol without caching is $26,000 a day, and on Astra $130,000.

Two things fall out of that table. The caching discount cuts this bill by 52% while nothing about the workload changed; the only difference is whether the leading 1,500 tokens stayed byte identical between calls. And the tier gap at volume is an order of magnitude, not a percentage. Choosing Luna over Sol here is a twentyfold decision, not a trim.

Workload B: large context retrieval

Here Luna’s 1,000,000 token window stops being a spec-sheet line. Assume a 200,000 token knowledge pack held stable across calls, a 2,000 token query, 600 output tokens, and 50,000 requests a day.

Caching takes 88% off the Luna bill here, against 52% in workload A. That gap is the whole point: the discount scales with the ratio of stable prefix to fresh tokens. A 200,000 token prefix re-read 50,000 times a day is the shape where prompt caching pays most.

Luna’s window is also larger than Sol’s 872,000 tokens, so a 900,000 token payload does not fit in the more expensive model and does fit in the cheaper one. That inverts the usual “promote to a bigger model when the payload grows” routing rule, covered in detail in what GPT-6 Luna actually is.

Workload C: the one-off backfill

Batch jobs are where the new pricing changes what is possible, not just what is cheap. Assume a 12,000,000 record enrichment pass: 900 tokens of stable instruction, 300 tokens per record, 250 output tokens.

A twelve million record backfill for under $3,000, or under $2,000 if the instruction prefix stays warm. That is a number a team can get approved in a single message. The same job on Sol needs a budget conversation.

Notice the ratio here. Output is now half the bill, which leads straight to the thing that actually determines your cost.

The three variables that decide the bill

1. Output tokens, because they bill at five times input

Luna’s output rate is 5x its input rate. In workload A with the prefix cached, input costs $65 per million requests and 120 output tokens cost $60. Loosen the response format to 400 tokens and output jumps to $200, taking the total from $125 to $265 per million requests. A response schema chosen in an afternoon more than doubled the bill.

The fix is boring and effective: constrain the output. Return an enum, not a sentence. Return a score, not an explanation, and fetch the explanation only for the small fraction of cases a human reviews. Pin the shape with a JSON schema so the model cannot pad:

{
  "model": "gpt-6-luna",
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "triage",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "category": { "enum": ["billing", "outage", "how_to", "abuse"] },
          "severity": { "type": "integer", "minimum": 1, "maximum": 4 }
        },
        "required": ["category", "severity"],
        "additionalProperties": false
      }
    }
  }
}

Confirm parameter names against OpenAI’s current model reference before building on this shape. The model ID gpt-6-luna is the part confirmed from the launch material.

2. Cache hit rate, because it is the only free 50% to 88% you will get

Everything above assumes the prefix stays byte identical. In production it usually does not, because someone injects a request ID into the system prompt or builds the tool array from a dictionary whose key order shuffles between processes. Two classic cache killers are now off that list: with GPT-6, changing reasoning effort or tool availability no longer invalidates the cache, and explicit breakpoints let you decide where the cached prefix ends. A Prompt Caching Dashboard and a diagnostics tool make hit rate something you measure rather than assume, and GitHub reports more than 50% fewer prompt tokens needing fresh processing across billions of requests. The mechanics are covered in our GPT-6 prompt caching walkthrough.

At volume, treat hit rate as a production SLI. A prefix refactor that silently drops you from 95% hits to 40% costs workload A roughly $400 a day and produces no errors, no alerts and no failing tests.

3. Retries, because they multiply

A 5% retry rate on workload A adds about $31 a day. Tolerable. The same 5% on workload B costs $50 a day if the retries miss the cache and $6 if they hit it, and the difference is entirely whether your retry rebuilds the prompt from scratch. Retries that regenerate a prefix are the most expensive resilience you can buy. Reuse the exact request body.

The latency trap at high QPS

Cheap is not fast, and at high QPS that bites. Third party measurements from Artificial Analysis put GPT-6 Luna at 153.9 output tokens per second with a time to first token of 124.23 seconds, and GPT-6 Sol at 102.15 seconds. Two caveats apply and both are load bearing: these are third party figures rather than vendor published, and they are measured on the max reasoning variants, the slowest configuration available.

Even so, the direction matters. Two minutes to first token will blow a default HTTP client timeout, idle out a load balancer and exceed the execution ceiling on most serverless runtimes. High QPS synchronous paths belong on low effort with streaming; high effort belongs in batch jobs and queue workers where nothing waits on a socket. Size timeouts against measured latency at the effort level you ship, not against the price.

Where the quality floor sits

Luna is not the smartest model in the family and OpenAI does not claim it is. Astra “continues to be our best model across the board” in OpenAI’s own words. What OpenAI does publish: Luna at max effort scores 66.6% on DeepSWE 1.1, comparable to Claude Opus 5 and Claude Fable 5 at medium effort, at 93% lower cost per task than Opus 5 and 96% lower than Fable 5. On AutomationBench 1.0.6 at high effort it beats its predecessor by 5.4 points at 58% lower cost per task. On OSWorld 2.0 offline at max effort it beats GPT-5.6 Sol at medium for a tenth the cost.

Those are vendor numbers measured against Claude Opus 5, not Opus 5.5, which shipped the same day, so treat them as directional. The operational reading is that Luna is the cheapest model clearing the bar for well specified, verifiable work, and “verifiable” is the load bearing word.

Prove the cost model before you commit to it

Spreadsheet arithmetic is a hypothesis. Test it on real traffic: take a 500 request sample of production payloads, run it against Luna and Sol as two environments, and record token counts, latency and schema conformance.

In Apidog, that is one saved endpoint with the model ID as an environment variable, run as a test scenario against a data file of real payloads. Add three assertions and the suite becomes a cost guardrail rather than a correctness check: assert the response matches your JSON schema, assert usage.completion_tokens stays under your per request output budget, and assert usage.prompt_tokens_details.cached_tokens is non-zero, so a prefix refactor that kills your cache hit rate fails CI instead of showing up on next month’s invoice. Confirm those usage field names against the current API reference before you assert on them.

That last assertion is the one nobody writes and everybody needs. The failure mode of a high volume LLM workload is almost never an outage. It is a 4x bill behind a green dashboard.

For how Luna’s pricing sits alongside GPT-6 Sol and Claude Opus 5.5 across the whole week, see our breakdown of the September 2026 AI model price war.

The short version

Route high volume, well specified, programmatically verifiable work to Luna and keep the stable part of your prompt byte identical. Cap output tokens, because they bill at five times input. Measure cache hit rate as a production metric. Keep high effort off synchronous paths until you have measured first token time on your own traffic. Do that, and the jobs that never shipped because the arithmetic did not work are worth costing again this week.