GPT-6 Luna Guide (Oct 2026): Pricing, Decisions API, 12h Cache and ChatGPT Free

Updated 2026-10-26: Added the Decisions API (beta 6 October, GA 22 October), 12-hour prompt cache pricing, Luna's new roles in ChatGPT Free/Go and as the GPT-4o/4.1 replacement, the Google Cloud private preview, the new Build/Launch/Grow rate-limit tiers, and a Claude Haiku 5.5 comparison with current Artificial Analysis data.

GPT-6 Luna is the model you reach for when you run something a million times a day and the per-call cost is the main design constraint. It shipped alongside GPT-6 Sol on 22 September 2026. In the five weeks since, its job has grown. OpenAI built a new endpoint around it, started rolling it out to ChatGPT's free tiers, and named it as the replacement for a batch of retiring GPT-4-era models.

This guide covers the published spec, the full rate card including the new 12-hour cache tier, the Decisions API, how Luna compares with GPT-5.6 Luna and Claude Haiku 5.5, and what Luna is bad at. Prices, specs and dates come from OpenAI's model, pricing, deprecation and changelog pages and Anthropic's pricing page. Benchmark figures come from Artificial Analysis's independent testing. The one exception, the ChatGPT rollout date, is attributed to a third-party report in its section.

What is GPT-6 Luna?

GPT-6 Luna is a reasoning model that accepts text and image input and returns text. OpenAI's model page describes it as "our most efficient model for focused, high-volume tasks." It sits below GPT-6.1 Sol (coding and agentic work) and GPT-6 Astra (the frontier tier).

Two details here trip people up.

The context window is not the input limit. Max input (922,000) plus max output (128,000) equals the 1,050,000 window. The output allowance is reserved out of the shared budget. Size prompts against 922,000, not 1,050,000.

reasoning.effort: none is supported. GPT-6 Astra does not accept none, according to OpenAI's 3 September changelog entry. Luna does, so you can run it as a plain non-reasoning model with no thinking-token overhead. For classification and extraction, that setting is the biggest lever on latency and usually a large saving against the default medium. Artificial Analysis's figures show that low can sometimes cost less per task, though (see the benchmarks section). One catch from the model page: function calling works through the Responses API at any effort, but through Chat Completions only when effort is none.

Luna supports streaming, structured outputs, function calling, prompt caching and image input. In the Responses API it can use web search, file search, image generation, code interpreter, hosted shell, apply patch, skills, computer use, MCP and tool search.

What does GPT-6 Luna cost?

Here is the full rate card per 1M tokens, from OpenAI's pricing page as of October 2026:

Batch and Flex run at 50% of standard. Fast mode (formerly priority processing) costs 2x. Regional data-residency endpoints add 10%.

The 12-hour prompt cache

On 20 October OpenAI added a 12-hour cache lifetime alongside the default 30 minutes. You select it with prompt_cache_options.ttl set to "12h" (the default is "30m") in the Responses API on GPT-5.6 and later models. Per OpenAI's prompt caching guide, a 30-minute write costs 1.25x the input rate and a 12-hour write costs 2.5x. Cached reads cost the same 0.1x either way, and the reusable prefix must be at least 1,024 tokens.

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-luna",
    "prompt_cache_options": { "ttl": "12h" },
    "input": "...long, stable system prompt and reference material, then the request..."
  }'

Is it worth it? Take a 50,000-token stable prompt prefix:

• 30-minute write: 50,000 × $0.125 / 1M = $0.00625
• 12-hour write: 50,000 × $0.25 / 1M = $0.0125
• Each cached read: 50,000 × $0.01 / 1M = $0.0005

One 12-hour write costs the same as two 30-minute writes. With the 30-minute cache you pay the first write, then another every time the cache expires and traffic comes back. One expiry in a 12-hour window means two writes ($0.0125), which ties with the 12-hour tier. Two or more expiries mean three or more writes ($0.01875 or more), and the 12-hour tier comes out cheaper. If requests arrive continuously, the 30-minute cache stays warm on its own and the 12-hour tier just doubles your write cost.

The 272K long-context cliff

Prompts over 272,000 input tokens are billed at 2x input and cache rates and 1.5x output for the full request, not just the tokens above the line. A 280,000-token prompt pays $0.20 per 1M input and $0.75 per 1M output. If you're near the line, trim below 272K. Retrieval that keeps prompts under the threshold pays for itself quickly at Luna's volumes.

Worked example: classifying a million tickets

Suppose you have 1,000,000 support tickets, about 300 input tokens each, at reasoning.effort: none, with roughly 5 output tokens for a JSON label:

• Input: 1,000,000 × 300 = 300M tokens × $0.10 / 1M = $30.00
• Output: 1,000,000 × 5 = 5M tokens × $0.50 / 1M = $2.50
• Total: $32.50 standard, or $16.25 through Batch

A shared instruction block above 1,024 tokens would add to input. But cached at $0.01 per 1M, it adds a tenth as much as the same tokens uncached.

GPT-6 Luna inside the GPT-6 family

Standard tier, prompts up to 272K, as of October 2026. Luna is 20x cheaper than either Sol on input and output, and 100x cheaper than Astra on input. It also has the freshest knowledge cutoff in the family, per OpenAI's model pages. GPT-6.1 Sol, released 29 September, has largely displaced GPT-6 Sol as the mid-tier choice. Artificial Analysis's leaderboard now lists GPT-6.1 Sol rather than GPT-6 Sol. For how the two launched together, see our GPT-6 Sol and Luna launch overview.

The Decisions API: Luna's dedicated endpoint

The biggest change since launch is a new endpoint built specifically for Luna. OpenAI released the Decisions API in public beta on 6 October and made it generally available on 22 October 2026. gpt-6-luna is the only supported model.

Decisions doesn't generate free text. You send shared evidence and a list of typed questions, and get back structured answers with probabilities. OpenAI's changelog describes it as turning text and images into typed answers "10x faster than the Responses API." That is a vendor claim. We have not seen an independent latency benchmark yet.

How it works

• Endpoint: POST /v1/decisions with model: "gpt-6-luna".
• Shared input: a string, or an ordered array of messages, tool calls and tool outputs. User messages can carry text, images, and an input_json content part for structured data.
• Questions: 1 to 400 per request at GA (200 during beta). Each has a type, a unique name and instructions. A request with many questions counts as one model request in usage reporting.
• Question types: predicate returns the probability that a condition is true. choice returns one of your supplied values plus probabilities and confidence. score returns a probability-weighted score across 2–10 ordered levels.
• Per-question images: set instructions to an array of input_text and input_image parts (base64 or public URL; file_id is not supported).
• Caching: by default an implicit cache breakpoint sits at the end of the shared input, so many questions reuse one cached prefix. The prefix needs at least 1,024 tokens, and prompt_cache_key partitions the cache.
• GPT-Live: since 15 October, GPT-Live can delegate to Decisions natively or trigger decisions from transcript deltas. A voice agent can pick an action from a spoken request without a full generation round trip.

Here is OpenAI's own routing example from the Decisions guide:

from openai import OpenAI

client = OpenAI()
decision = client.decisions.create(
    model="gpt-6-luna",
    input="I was charged twice for my order.",
    questions=[
        {
            "type": "choice",
            "name": "department",
            "instructions": "Which department should handle this complaint?",
            "choices": [
                {"value": "billing", "description": "Payments, invoices, and refunds."},
                {"value": "technical", "description": "Problems using the product."},
                {"value": "shipping", "description": "Delivery and tracking."},
                {"value": "other", "description": "Requests outside these categories."},
            ],
        }
    ],
)

answer = decision.answers[0]
if answer.type == "refusal":
    print(f"Refused: {answer.name}")
elif answer.type == "choice":
    print(f"Department: {answer.choice} (confidence: {answer.confidence})")

Pricing. OpenAI's Decisions guide says requests bill at Luna's input token rates, with discounted cache hits and charged cache writes, and that output tokens aren't charged. Long-context multipliers and regional premiums can still apply. As of October 2026 the main pricing page has no separate Decisions line. Check usage.input_tokens_details (or the /v1/organization/usage/decisions admin endpoint) rather than estimating.

When to use it. Reach for Decisions for routing, moderation-style yes/no checks, rubric scoring and multi-label tagging, where you want calibrated probabilities instead of a parsed string. Many questions over one shared, cached document is the pattern it was designed for. Use the Responses API when you need generated text, tool calls or reasoning traces.

Where GPT-6 Luna now runs

ChatGPT Free and Go

According to we0.ai's report on OpenAI's 7 October "GPT-6 for everyone" announcement, OpenAI began rolling GPT-6 Luna out to ChatGPT Free and Go users on 8 October 2026, replacing GPT-5.6 Luna in the main Chat experience. The same report says the models behind Work and Codex did not change. We could not load OpenAI's announcement page directly to confirm these details, and a rollout that begins on a date may not reach every account that day. For developers, this matters mostly as a signal. Luna is the model OpenAI trusts to carry its largest user base.

Luna's role in the GPT-4o/4.1 retirement

On 14 October, according to its deprecations page, OpenAI announced that gpt-4o-2024-08-06, gpt-4o-2024-11-20, gpt-4o-mini-2024-07-18, gpt-4.1-2025-04-14 and gpt-4.1-mini-2025-04-14 will be removed from the API on 14 January 2027. Fine-tuned versions follow the same schedule. All five snapshots (across four model families) list gpt-6-luna as the replacement. Swapping the model ID is not the whole job, because Luna is a reasoning model with different defaults. Our GPT-4o and GPT-4.1 shutdown migration guide walks through the latency, tool-calling and sampling-parameter changes.

Google Cloud private preview

On 21 October Google Cloud announced that GPT-6 Luna, GPT-6.1 Sol and GPT-6 Astra are rolling out in private preview to select enterprise customers in its Model Garden. Usage is billed through Google Cloud Marketplace and draws down existing cloud commitments. Google has not published a general-availability date or per-token pricing for this route as of October 2026.

GPT-6 Luna vs GPT-5.6 Luna

The upgrade is mainly a price cut. Context limits, effort levels and the 272K threshold are all identical, so the migration is a model-string change plus an eval run. Artificial Analysis no longer lists GPT-5.6 Luna on its main leaderboard, so we can't give a current like-for-like intelligence comparison. If you're still on GPT-5.6 Luna, the half-price input and 58% cheaper output are reason enough to move. For the previous generation, see our GPT-5.6 Sol, Terra and Luna guide.

GPT-6 Luna benchmarks (independent)

Artificial Analysis measures Luna at every reasoning effort. Its model page labels the score as Intelligence Index v4.3.2. The figures below are a snapshot of its leaderboard taken on 26 October 2026. All are independently measured, not vendor-reported. AA can also revise scores and cost per task when it re-runs a model. Output speed and time to first chunk are rolling medians that change daily, so treat them as approximate.

The spread is the useful part. Going from none to max roughly doubles the index (18 to 38), but time to first chunk rises from under a second to around a minute and a half. Pick effort per task, not per application. One oddity, checked against AA's underlying data: the non-reasoning run costs more per task than low ($0.011 vs $0.0045). AA doesn't break down why. Cost per task depends on how many tokens the model actually spends on AA's test set, so don't assume none is always cheapest. Measure on your own traffic. AA's blended price for Luna is $0.08 per 1M tokens on its 7:2:1 cache-hit/input/output mix.

Where Claude Haiku 5.5 fits as Luna's closest rival

Luna's closest rival is now Anthropic's Claude Haiku 5.5, which matches Luna's headline price for prompts up to 100,000 tokens.

Prices are from OpenAI's and Anthropic's pricing pages as of October 2026. Index scores are from Artificial Analysis (independent).

Three takeaways:

• Haiku 5.5 scores higher at the top. 43 vs 38 at max effort, but at three times the AA cost per task ($0.21 vs $0.07).
• At equal quality, Haiku is faster. Haiku 5.5 at high also scores 38, at $0.08 per task, with a first chunk in about 26 s and about 185 tok/s. Luna at max gets 38 for $0.07, with a first chunk in about 94 s and about 129 tok/s (AA rolling medians, 26 October snapshot). For roughly the same cost per task, Haiku responds much sooner.
• Luna wins on long prompts. For a 150,000-token prompt with 1,000 output tokens, Haiku costs 150,000 × $0.50 / 1M + 1,000 × $2.50 / 1M = $0.075 + $0.0025 = $0.0775. Luna costs 150,000 × $0.10 / 1M + 1,000 × $0.50 / 1M = $0.015 + $0.0005 = $0.0155, about 5x less.

Our Haiku 5.5 guide's head-to-head section has costs at 10K, 120K and 300K prompts and a verdict by workload.

How Luna compares with other cheap-tier models

On Artificial Analysis's leaderboard (independent; snapshot taken 26 October 2026, with output speed as an approximate rolling median), Luna's competitors in the fast tier score as follows:

Luna has the lowest intelligence score in this group and by far the lowest cost per task. AA's Gemini 3.8 Flash cost-per-task figure changed while we were checking it on 26 October (an earlier reading that day showed $1.24), so recheck it before relying on it. If your workload is quality-sensitive at the margin, one of the higher-scoring models may justify three to four times Luna's cost per task (Haiku about 3x, DeepSeek about 3.7x, GLM about 4x). Gemini 3.8 Flash is far more expensive per task, about 50x in this snapshot ($3.49 / $0.07). If it's a high-volume pipeline where an eval shows Luna is good enough, nothing else here comes close on price. Luna's other advantages are the 12-hour cache option (Haiku tops out at 1 hour), the Decisions endpoint and OpenAI's full hosted-tool surface. Its 90% cache-read discount is matched by Haiku 5.5. The open-weight options (DeepSeek, GLM) can be self-hosted, which matters for data residency. For list prices across vendors, see our comparison of the cheapest fast LLM APIs.

What is GPT-6 Luna good for?

Classification, routing and scoring. Use the Decisions API if you want probabilities, or Responses with reasoning.effort: none and a structured-output enum. This is what Luna was built for.

Extraction over large documents. With 922,000 usable input tokens you can push a contract set or log dump into one call. A 250,000-token document costs 250,000 × $0.10 / 1M = $0.025 to read, and staying under 272K keeps you off the 2x cliff.

High-volume summarisation. Output is the expensive side at $0.50 per 1M, so cap max_output_tokens.

The cheap worker in an agent loop. Let Luna decide which tool to call, and hand the steps that need judgement to GPT-6.1 Sol.

Anything behind a stable prompt. Cached reads at $0.01 per 1M, now with a 12-hour lifetime option, make a long fixed instruction block almost free to reuse.

Where GPT-6 Luna will disappoint you

• Serious coding. Luna (max) scores 38 on AA's index against 52 for GPT-6.1 Sol (max). Use Luna to triage a bug report and Sol to fix it.
• Long multi-step agentic runs. Per-step quality gaps compound. A step that is 90% reliable is about 35% reliable over ten steps (0.9¹⁰ ≈ 0.35).
• Latency-critical UX at high effort. At max, AA's rolling median for first chunk is about 90 seconds or more. Drop to none (about 0.9 s) or low (about 3 s) for interactive use. Reasoning effort controls latency, not the model tier.
• Hard reasoning and research. That is what Astra is for. Paying for max reasoning on a model not built to reason is the most common way teams waste money on the cheap tier.

What about "GPT-6 Luna Pro"?

There is no separate Luna Pro model. The model page lists a single snapshot, gpt-6-luna. OpenAI's reasoning guide says GPT-5.6 and GPT-6 models support reasoning.mode: "pro" for difficult tasks that can tolerate higher latency and token usage. Pro mode bills at the model's standard per-token rates but does more work, so each answer costs more by a variable amount. If you run Luna at none or low because cost is the point, pro mode works against you. If you need that much more quality, compare against GPT-6.1 Sol first.

How do you use GPT-6 Luna?

Here is a Responses API call with reasoning disabled and structured output, the setup you want for classification:

from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-6-luna",
    input="Classify this ticket: My card was charged twice this month.",
    reasoning={"effort": "none"},
    max_output_tokens=16,
    text={
        "format": {
            "type": "json_schema",
            "name": "ticket_label",
            "schema": {
                "type": "object",
                "properties": {
                    "label": {
                        "type": "string",
                        "enum": ["billing", "bug", "feature_request"],
                    }
                },
                "required": ["label"],
                "additionalProperties": False,
            },
        }
    },
)

print(resp.output_text)

Set these on every production Luna call:

1. Pick reasoning effort explicitly. The default medium spends thinking tokens you may not need.
2. Cap max_output_tokens. Output costs 5x input, and the ceiling is 128,000 tokens.
3. Use Batch for anything not interactive. It's half price for the same model.
4. Choose a cache lifetime deliberately. Use 30 minutes for steady traffic and 12 hours for bursty traffic over a large stable prefix.

On 6 October OpenAI cut usage tiers from five to three. Luna's default limits are now:

Should you use GPT-6 Luna?

If you're on GPT-5.6 Luna, move. Same limits, half the input price, and access to Decisions.

If you're on a retiring GPT-4o or GPT-4.1 snapshot, Luna is the official target. Budget time for reasoning-model differences before 14 January 2027.

If you're choosing a cheap tier fresh, run your eval on Luna and Haiku 5.5 side by side. Luna is cheaper per task and much cheaper on prompts over 100K tokens. Haiku scores higher and responds faster at equal quality.

If you're reaching for Luna to save money on hard work like multi-step agents, real coding or novel reasoning, stop. The 14-point AA gap to GPT-6.1 Sol is the one that matters. Use Luna for the volume and Sol or Astra for the judgement.

FAQ

How much does GPT-6 Luna cost?

As of October 2026: $0.10 per 1M input tokens, $0.01 cached, $0.50 output. Cache writes are $0.125 per 1M for 30 minutes or $0.25 for 12 hours. Batch and Flex are half price. Prompts over 272,000 input tokens pay 2x input and cache rates and 1.5x output.

What is the OpenAI Decisions API?

It's an endpoint at /v1/decisions that returns typed answers (predicate probabilities, choices or scores) instead of free text. It runs only on gpt-6-luna, went GA on 22 October 2026, and accepts up to 400 questions per request over shared text, image or JSON input. OpenAI's changelog says it returns typed answers 10x faster than the Responses API (a vendor claim).

Is GPT-6 Luna the model in ChatGPT Free?

It is rolling out there. According to we0.ai's report on OpenAI's 7 October announcement, GPT-6 Luna began replacing GPT-5.6 Luna in the Chat tab for Free and Go users on 8 October 2026. Work and Codex did not change.

Is GPT-6 Luna the cheapest option for long prompts?

Among the models compared here, yes. Luna stays at base rates up to 272,000 input tokens and then pays $0.20 input / $0.75 output per 1M. Claude Haiku 5.5 matches Luna's $0.10 / $0.50 only up to 100,000 tokens and then jumps to $0.50 / $2.50. A 150,000-token prompt costs about 5x more on Haiku.

Is GPT-6 Luna good for coding?

Not for serious coding. Artificial Analysis scores Luna (max) at 38 against 52 for GPT-6.1 Sol (max). Use Luna to triage and label bug reports, and hand the implementation work to Sol.

What's the difference between GPT-6 Luna, Sol and Astra?

Price and capability. As of October 2026, Luna costs $0.10 / $0.50 per 1M input/output tokens, both Sol models cost $2 / $10, and Astra costs $10 / $50. Luna supports reasoning.effort: none, and Astra does not. Luna also has the latest knowledge cutoff (18 May 2026).

Does GPT-6 Luna support image input?

Yes. It accepts text and image input and returns text only. It does not generate images or audio directly. Image generation is available only as a hosted tool in the Responses API.

What is GPT-6 Luna's context window?

1,050,000 tokens, split into a maximum of 922,000 input and 128,000 output.

Is GPT-6 Luna available on Google Cloud?

Only in private preview for select enterprise customers in Google Cloud's Model Garden, announced 21 October 2026. No GA date has been published.

Sources

• OpenAI: GPT-6 Luna model page
• OpenAI: API pricing
• OpenAI: API changelog
• OpenAI: Decisions API guide
• OpenAI: Prompt caching guide
• OpenAI: Reasoning guide
• OpenAI: Deprecations
• OpenAI: GPT-5.6 Luna model page
• OpenAI: GPT-6 for everyone
• Google Cloud: OpenAI models come to Google Cloud
• Anthropic: Claude pricing
• Artificial Analysis: Model leaderboard
• Artificial Analysis: GPT-6 Luna
• we0.ai: GPT-6 free rollout (ChatGPT plan dates)

If your team is building high-volume pipelines on models like Luna, Codersera can help you hire vetted remote AI developers who have already worked through these cost and reliability trade-offs.