GPT-5.6 Sol vs Luna: API Pricing, Limits and Which to Use

What is the difference between GPT-5.6 Sol and Luna?

GPT-5.6 Sol and GPT-5.6 Luna are members of OpenAI's GPT-5.6 model family, but they are designed for different types of work. Sol is the flagship model in the family, positioned for complex professional tasks, while Luna is optimised for applications where low cost and high-volume processing are important.

The difference is not simply that one model accepts more text than the other. OpenAI's current API specifications give both models the same maximum context window and output token allowance. The practical distinction is how much capability an application needs for its particular workload and what it costs to obtain the required results.

Sol can be used for difficult coding, multi-step analysis, professional research, complex document work and workflows involving several dependent decisions. Luna is intended for cost-sensitive, high-volume processing such as routine classification, extraction, summarisation and focused automation.

These are useful starting points rather than absolute restrictions. Luna can perform reasoning tasks and use tools, while Sol can handle simple requests. The appropriate choice depends on how the models perform on the application's own test cases.

Developers can select the models independently through their respective API identifiers. The general gpt-5.6 alias currently routes to GPT-5.6 Sol, so an application intending to use Luna should specify gpt-5.6-luna explicitly.

Official model specifications: GPT-5.6 Sol and GPT-5.6 Luna .

GPT-5.6 Sol vs Luna API pricing

OpenAI charges for API usage according to the tokens processed and generated, with additional charges possible for tools or optional processing services. Input tokens represent material sent to the model, while output tokens represent material generated by the model, including billable reasoning tokens.

As of 22 September 2026, GPT-5.6 Sol costs $4 per million standard input tokens and $20 per million output tokens. GPT-5.6 Luna costs $0.20 per million standard input tokens and $1.20 per million output tokens.

At these rates, Sol's uncached input tokens cost 20 times as much as Luna's, while its output tokens cost approximately 16.7 times as much. These are differences in published token rates, not predictions of the total cost of completing the same task.

Why older articles show different prices

OpenAI's initial GPT-5.6 announcement listed higher prices for both models. Since then, the company has reduced Luna's API pricing and introduced promotional pricing for Sol. Consequently, an older comparison may show Sol at $5 per million input tokens and $30 per million output tokens, or Luna at $1 per million input tokens and $6 per million output tokens.

Those figures do not represent the current standard rates shown in OpenAI's model and pricing documentation. OpenAI states that Sol's promotional pricing is available at least through 21 November 2026. Its pricing after that date should be checked rather than assumed.

Long-context pricing can increase the cost

Both models support very large input contexts, but requests containing more than 272,000 input tokens enter a higher pricing band. OpenAI specifies that these requests are charged at twice the standard input rate and 1.5 times the standard output rate for the full request.

This is an important distinction: the higher rates apply to the whole qualifying request rather than only the input tokens above the threshold.

How prompt caching affects API bills

GPT-5.6 supports prompt caching, which can reduce the cost of repeatedly processing the same prompt prefix. For both models, eligible cached-input reads receive a 90% discount relative to the corresponding uncached input rate. Cache writes are billed at 1.25 times the applicable uncached input rate.

OpenAI's GPT-5.6 caching system provides a 30-minute minimum cache lifetime. An application that repeatedly processes the same instructions or source material may benefit from retaining reusable prompt prefixes.

However, caching is not equivalent to permanently storing a document for free. Cache writes have a cost, cache reuse depends on eligible matching content, and the application still pays for newly generated output tokens.

Official pricing references: OpenAI API pricing and prompt caching documentation .

What would Sol and Luna cost for the same API workload?

Token prices become easier to understand when applied to a concrete workload. Consider an application that submits 10,000 uncached input tokens and receives 2,000 billable output tokens per request. Assume standard short-context pricing, no chargeable tools and the same token counts for both models.

For this example, processing 1,000 requests costs $80 with Sol and $4.40 with Luna. That difference can become significant in an application processing thousands of documents, support messages or automated tasks every day.

Nevertheless, these figures are estimates for a controlled example, not measured production costs. Sol and Luna may generate different numbers of output tokens, use different amounts of reasoning, or require different numbers of attempts to complete a task.

A cheaper request does not automatically mean a cheaper successful outcome. If an application needs extensive corrections or retries, those additional requests also consume tokens.

The practical way to compare total cost

Test both models against a representative collection of real tasks, using the same acceptance criteria. Record their input and output tokens, tool calls, latency, error rates and number of attempts required to produce an acceptable result.

For example, an application extracting invoice fields might measure how often each model returns the correct values in the required JSON structure. A coding application might compare whether the generated change passes the same automated tests.

The resulting cost per accepted outcome is more informative than comparing the listed price of a single request in isolation.

Context window and maximum output limits

One of the less obvious differences between model families is that a lower-cost model does not always have a substantially smaller context window. In this case, OpenAI lists the same maximum context window for GPT-5.6 Sol and Luna.

Does the same context window mean equal intelligence?

No. A context window describes the amount of tokenised material a model can accommodate in a request. It does not independently measure reasoning quality, accuracy, instruction following or the ability to use information spread across a long document.

Both models may technically accept a large collection of documents, but an application should still verify whether the selected model can extract and combine the required information reliably.

For a simple classification task involving long documents, Luna may be worth testing because of its lower token cost. For a difficult analysis that requires reconciling conflicting evidence, Sol may be worth testing for its professional-work capabilities.

Does 128,000 output tokens mean every response will be that long?

No. The published maximum is a capacity ceiling, not a guaranteed response length. The actual output depends on the request, the configured output limit, available context, reasoning consumption, and other applicable runtime constraints.

Applications should request the length they genuinely need rather than automatically allocating the maximum output allowance to every task.

What happens with very large prompts?

Input length affects both the cost of a request and how much context remains available for the model's reasoning and generated response. Requests exceeding 272,000 input tokens also enter the long-context pricing band described earlier.

A large context window is useful when a task genuinely requires extensive source material. It is not a reason to send every available file to the model. Retrieving relevant passages, reducing duplicated text and keeping prompts focused can make applications easier to evaluate and less expensive to operate.

Model specifications: Sol context and output limits and Luna context and output limits .

GPT-5.6 Sol vs Luna API rate limits

API rate limits determine how much traffic an organisation can send to a model within a specified period. They are different from a model's context window and output limit. A model may support a very large individual request while the API still restricts the number of requests or tokens that can be processed over time.

OpenAI lists separate request-per-minute and token-per-minute limits for Sol and Luna. The available limits depend on the organisation's API usage tier.

The tables below reproduce the published limits reviewed on 22 September 2026. Account-specific restrictions or future changes may alter the limits available to a particular application.

GPT-5.6 Sol rate limits

GPT-5.6 Luna rate limits

Both models have the same published Tier 1 allowance of 500 requests per minute and 500,000 tokens per minute. At higher tiers, Luna has larger published token allowances and, at Tier 5, a higher request-per-minute allowance.

What do RPM and TPM mean?

RPM means requests per minute. TPM means tokens per minute. A request can be blocked when either the request rate or token rate is exhausted, even if the other limit has not been reached.

For example, an application handling long documents may reach its token limit before reaching its request-per-minute limit. A service handling very short messages may encounter the opposite situation.

Are the API models free?

The official model pages list the Free API usage tier as unsupported for both Sol and Luna. Access through a ChatGPT subscription does not automatically provide the same model allowance through the developer API.

Developers should check their API organisation's billing configuration, available models and current usage tier before deploying an application.

Official rate-limit tables: Sol rate limits and Luna rate limits .

Reasoning, coding and tool support

Both Sol and Luna support reasoning controls, structured outputs, function calling and image input. The official model pages also list support for tools such as web search, file search, code execution and computer use through compatible Responses API workflows.

Support for a capability does not establish identical performance when using it. A model's ability to call a tool and its ability to plan, verify and complete a complicated multi-step task are separate questions.

Reasoning effort

The two models expose the same documented reasoning-effort options: none, low, medium, high, xhigh and max. Medium is the documented default for both models.

Higher reasoning effort can make sense for tasks that require additional analysis or verification, but it can also increase latency and the number of billable output tokens.

An application should not automatically assign maximum effort to every request. A routine classification task and a complex engineering problem may require different reasoning budgets.

Coding and complex professional work

OpenAI positions Sol as its GPT-5.6 flagship for complex professional work. It is a model to evaluate for difficult debugging, software implementation, multi-source research, long technical assignments and complex workflows requiring several dependent decisions.

Luna can also handle coding and reasoning tasks. Its lower price may make it useful for focused code classification, extracting information from files, routine transformations and other high-volume development workflows.

For a difficult production coding problem, the developer should compare test-pass rates, retries and total completion cost instead of relying only on the advertised token price.

Tool calling and structured outputs

Both models support function calling and structured outputs. These capabilities allow an application to request information in a defined format and connect the model to approved external functions or services.

A support platform, for example, might use a model to classify an incoming message and return a structured category. An agentic application might request tool calls to retrieve relevant documents before composing an answer.

The model should only receive access to the tools and actions required by the task. Important external changes should have suitable validation and authorisation.

Image input and other modalities

OpenAI's model pages list both Sol and Luna as supporting text input and output, together with image input. Audio and video are not listed as supported native input or output modalities for these model endpoints.

Developers building voice or video applications should distinguish these models from OpenAI's dedicated audio, video and realtime offerings.

Official capabilities: Sol model page and Luna model page .

Which model should you use for your application?

Model selection becomes more useful when it starts with the task an application must complete rather than the price of an individual token. The following examples illustrate how different requirements can affect a developer's choice.

When Sol is worth evaluating

Sol is relevant when the task requires difficult reasoning, substantial synthesis, sophisticated code changes or the coordination of multiple dependent operations.

In these cases, a higher token price may be acceptable if the model completes more tasks correctly or avoids expensive follow-up work. That benefit needs to be established through testing rather than assumed from the model name.

When Luna is worth evaluating

Luna is relevant when an application processes large numbers of relatively routine requests and operating cost matters.

Examples include extracting structured fields from repeated document formats, classifying support tickets, organising large collections of text and generating focused summaries.

Its published token prices and higher-tier throughput allowances can be useful in applications that need to process large volumes of material.

A mixed-model workflow

An application does not need to send every request to the same model. For example, Luna could classify incoming support messages and extract the important details. Straightforward cases could then follow an established workflow.

Requests requiring more difficult investigation could be sent to Sol with the relevant evidence and the original task constraints.

Such a system needs a clear routing rule, acceptance checks and safeguards against losing important information during escalation. Its cost advantage, if any, should be measured against a simpler single-model implementation.

How to use GPT-5.6 Sol and Luna in the API

Both models are available through the OpenAI API. The important first step is selecting the correct model identifier in the request.

Example: Send a request to Luna

The Responses API accepts a model identifier and an input containing the task to be completed. The following command shows the basic request structure for using Luna.

The environment variable OPENAI_API_KEY must contain an authorised API key. Keep API keys in a secure server-side environment. Do not embed them in public website code or expose them to browser users.

Example: Switch the request to Sol

To select Sol, use its model identifier in the request.

The same general API interface can support both models. A developer can therefore compare them without creating a completely separate application for each one.

These examples illustrate the documented request format. Actual execution requires an API account with the appropriate model access, available usage allowance and compatible project settings.

How to test the models fairly

A meaningful comparison should use representative tasks and predetermined acceptance criteria. A model that generates shorter answers or uses less reasoning may appear cheaper even when it fails to complete the full task.

1. Select representative tasks. Use examples that reflect the real application rather than relying on a single demonstration prompt.
2. Define what a correct result looks like. Specify the required information, output format, constraints and validation checks before testing.
3. Record token consumption. Track input tokens, cached-input usage, reasoning and output tokens, including any repeated requests.
4. Measure task completion. Check whether the result satisfies the original requirements, passes applicable tests and contains the necessary evidence.
5. Compare total operating cost. Include retries, tool charges, latency and any additional processing needed before the output becomes usable.

Official API references: Text generation with the API and OpenAI model identifiers .

Which GPT-5.6 model should you choose?

The decision depends on what an application needs to accomplish and how reliably each model completes that work. GPT-5.6 Sol is positioned for complex professional tasks, while GPT-5.6 Luna is designed for cost-sensitive, high-volume applications.

Both models support large contexts, reasoning controls and a broad set of API tools. Consequently, the presence of a feature on a model's specification sheet is not enough by itself to determine which model will deliver a satisfactory result for a particular application.

For routine, high-volume work

Evaluate Luna against the required accuracy, throughput and cost targets.

For difficult professional tasks

Evaluate Sol against the required reasoning, implementation and verification criteria.

For mixed workloads

Test whether routing routine requests to Luna and escalating complex requests to Sol improves total cost and completion reliability.

For very long inputs

Account for the higher pricing band above 272,000 input tokens and measure the model's performance on the actual source material.

The practical next step is to test both models on the same representative workload. Measure whether their outputs satisfy the task, then compare the total tokens, latency, retries and tool charges needed to reach that result.

Before moving into production, confirm current pricing and account-specific limits in the official API pricing documentation and your organisation's API limits settings .