Why does GitHub Copilot apply GPT-5.6 Luna long-context pricing above 200K tokens when OpenAI’s API threshold is 272K?

[MSLeiter]

🏷️ Discussion Type

Question

💬 Feature/Topic Area

VS Code

Body

For GPT5.6-Luna, the OpenAI public API sheet shows a pricing bump from $0.20/$1.20 to $0.40/$1.80 at 272k context size.

However, for Copilot, both public Copilot price sheet and the internal models.json file that has the pricing information per model shows that Luna's price tiers are based on only 200k context.

Why is there this difference? I would expect the OpenAI API pricing that appears to be applied directly to every other model from OpenAI that is available in Copilot (and I believe for all other providers as well) to apply to Luna as well. In Codex I also get 272k context before the price increase.

Is this a mistake that can be resolved? Or has Microsoft deliberately decided that Luna should cost more between 200k and 272k for Copilot users than for Codex/OpenAI API users? If so, please share the justification for users.

Thank you!!

Resources

• Copilot Doc Link showing Luna at 200k context cutoff
• OpenAI docs showing 272k context length before price bump
  • OpenAI states:“Prompts with >272K input tokens are priced at 2x input and 1.5x output for the full request.”
• Table based on Models.json pricing data, taken from linux VS Code install:
  • 

[Kushan20070126]

This looks like a pricing-policy difference worth clarifying with GitHub, rather than assuming the Copilot pricing table is directly derived from OpenAI's API pricing.

GitHub's current Copilot pricing table explicitly puts GPT-5.6 Luna into two tiers:

≤ 200K input tokens
Input:        $0.20 / 1M
Cached input: $0.02 / 1M
Output:       $1.20 / 1M

> 200K input tokens
Input:        $0.40 / 1M
Cached input: $0.04 / 1M
Output:       $1.80 / 1M

GitHub therefore appears to have defined its own billing threshold for Luna at 200K.

The important distinction is that the model's context window and the billing threshold are different things. OpenAI currently lists GPT-5.6 Luna with a 1.05M-token context window and $0.20/$1.20 base pricing. A larger context window does not itself determine where GitHub must place its Copilot billing tier.

So I would ask GitHub to clarify one specific point:

Is the 200K Copilot threshold an intentional commercial pricing rule negotiated for Copilot, or is it a documentation/configuration error?

If it is intentional, it would also be useful for GitHub to document why Luna differs from GPT-5.6 Sol and Terra, which currently use a 272K threshold in the Copilot pricing table.

That would also explain why comparing Copilot's models.json directly with OpenAI API pricing might not produce identical thresholds. The two services have separate billing systems even when they expose the same underlying model.

[anushka1330]

I think the important distinction here is model context capacity vs. billing tier.

The two published tables currently do show a real discrepancy:

• OpenAI's GPT-5.6 Luna API pricing says the higher pricing applies to prompts above 272K input tokens.
• GitHub Copilot explicitly defines Luna's long-context tier as above 200K input tokens.
• Meanwhile, Copilot uses 272K as the threshold for GPT-5.6 Sol and Terra.

So this doesn't look like a misunderstanding of Luna's context window. It looks like GitHub has configured a different billing threshold for Luna in Copilot.

I wouldn't assume that this is necessarily a bug, though. GitHub's Copilot billing is its own token-based pricing system, and GitHub documents the Copilot rates separately from the provider's API pricing. The fact that the underlying model is hosted by OpenAI/GitHub infrastructure doesn't by itself require the billing tiers to match the public API.

That leaves one question GitHub could answer quite cleanly:

Is the 200K Luna threshold intentional, or is it a configuration/documentation error?

If intentional, documenting why Luna uses 200K while Sol/Terra use 272K would make the pricing much easier for users to understand. If it's accidental, models.json and the public Copilot pricing page should presumably be aligned.

That seems more actionable than treating the 200K figure as Luna's actual context limit—the OpenAI API documentation currently lists Luna with a 1.05M-token context window.