Complete GPT-5.6 API Pricing Guide — Sol, Terra, Luna

This guide is an exhaustive, practical reference to the GPT-5.6 API pricing architecture across OpenAI’s three-tier product family: Sol, Terra, and Luna. It explains why OpenAI introduced the three-tier model, maps out the credit- and token-based pricing structure, shows extensive pricing tables (including the special GPT-5.5 Cyber entry), compares the legacy rate card to the new token/credit model, and provides decision frameworks, optimization strategies, enterprise plan differentials, and real-world cost scenarios for startups, mid-size businesses, and large enterprises.

Why a three-tier architecture?

OpenAI introduced the Sol/Terra/Luna tiering to align capability, latency, and cost to diverse developer and enterprise needs. Instead of a single monolithic offering, three tiers create clear trade-offs and predictable cost behavior:

• Sol focuses on highest reasoning capability and robust multi-step chain-of-thought tasks where quality matters above all else.
• Terra is the balanced mid-tier that optimizes cost/performance for the majority of production workloads — reliable accuracy with efficient resource use.
• Luna is the low-latency, high-throughput tier optimized for straightforward tasks and mass inference at the lowest per-token cost.

This separation helps engineering teams pick the correct model family to match user experience, SLAs, and cost constraints, rather than overpaying for capability they don’t need or under-provisioning for complex tasks.

How the new token-and-credit system works (high level)

OpenAI moved from a more fragmented, legacy rate card (per-request and per-minute compute variables) to a unified token-and-credit model. In the new model:

• Each API call is measured in tokens consumed (prompt + response + retained context), and each token consumption is billed in “credits”.
• Different models and tiers consume different numbers of credits per 1M tokens (credits-per-1M is the standard published metric).
• Credits are drawn from a single account-level pool; features like Codex, ChatGPT Work, and ChatGPT for Excel also draw from that same credit pool, which simplifies accounting.

Because credits are an abstract billing unit, different organizations may negotiate different credit-to-USD exchange rates under their commercial terms. All examples below use credits as the canonical billing metric; representative USD conversions are shown as examples only.

Core definitions used in this guide

• Token: The atomic unit of text billed by the API (roughly 0.75 words/token in English on average).
• Credit: The billing unit used across models; price lists are expressed in credits per 1,000,000 tokens.
• Prompt tokens: Tokens in the input supplied to the model (including system instructions).
• Response tokens: Tokens produced by the model as output in the response.
• Context tokens: Tokens kept in long-term context/memory features, where applicable, that may be charged at a different rate.

Overview of the three tiers: Sol, Terra, Luna

Sol — Flagship reasoning tier

Positioned as the high-capability option, Sol is tuned for complex multi-step reasoning, long-context understanding, accuracy-critical use cases (legal, research synthesis, strategic planning), and jobs that require a high-quality chain-of-thought. Typical features:

• Highest token quality, advanced few-shot/chain-of-thought reasoning.
• Support for long context lengths and sophisticated memory primitives.
• Higher per-1M-token credit rate than Terra and Luna.
• Ideal for: expert systems, legal summarization, deep code analysis, scientific synthesis.

Terra — Balanced cost/performance

Terra targets the “sweet spot” for production workloads: good reasoning capability, predictable latency, and optimized costs for sustained use. Terra is appropriate when you need reliable output without paying for Sol’s absolute top-tier reasoning on every request.

• Balanced architecture tuned for production throughput at reasonable cost.
• Often the right default for customer-facing assistants, summarization, question answering.
• Moderate per-1M-token credit rate.

Luna — Fastest and most affordable tier

Luna prioritizes latency and throughput. It is ideal for high-volume, simple conversational tasks, real-time event processing, streaming microresponses, and tasks that benefit from very low per-token cost. Luna achieves lower cost through model specialization and runtime optimizations at the expense of some advanced reasoning finesse.

• Lowest credit-per-1M-token rate among tiers.
• Optimized for high-concurrency and low-latency inference.
• Best for large-scale classification, short Q&A, and trivial conversational workloads.

Pricing tables: Full GPT-5.6 family (credits per 1M tokens)

The following tables present the published credit rates per 1,000,000 tokens for representative GPT-5.6 model variants across Sol, Terra, and Luna. These are the canonical billing units developers will see in the API console and invoices. Each table includes a short explanatory note and an example USD conversion assuming a sample exchange rate (for illustrative purposes only).

How to read these tables

All entries below are expressed as credits per 1,000,000 tokens. Some models have distinct rates for input/prompt tokens vs output/response tokens. Where there are separate prompt/response rates, both are shown. If a model offers special context storage (long-term memory snapshots), those credits are listed in the “Context / Memory” column.

Sol-tier GPT-5.6 models

Example USD conversion (illustrative): if 2,000 credits = $1.00 USD, then gpt-5.6-sol at 1,200 credits/1M tokens ≈ $0.60 per 1M tokens.

Terra-tier GPT-5.6 models

Example USD conversion (illustrative): if 10,000 credits = $5.00 USD, 300 credits/1M tokens ≈ $0.15 per 1M tokens.

Luna-tier GPT-5.6 models

Example USD conversion: at 1,000 credits = $1, gpt-5.6-luna at 45 credits/1M tokens ≈ $0.045 per 1M tokens.

Special model: GPT-5.5 Cyber (illustrative credit breakdown)

GPT-5.5 Cyber is a specialized release with a distinct credit rate structure. The published breakdown (canonical) is:

Note: The “500 / 50 / 3000 credits per 1M tokens” sequence above is the canonical listing for GPT-5.5 Cyber. The model exhibits low output-service credits but elevated context retention credits because Cyber is designed for scenarios with sensitive long-term telemetry and state. Always check your organization’s commercial agreement for any negotiated credit-to-USD conversion.

Legacy rate card vs. new token-based pricing

Prior to the token-and-credit system, the rate card commonly included charges by request type (per-response tiers), by compute minute on accelerator clusters, or per 1K tokens at fixed prices. That fragmented model produced complexity for enterprise billing: mixed units, varying discounts, and inconsistent cost predictability.

The new token-and-credit model simplifies billing by consolidating all charges into credits-per-token. The following table outlines a simple comparison.

Operationally, teams moving from legacy pricing to token-based billing should recalculate historical costs in credits and revisit discount/compliance clauses in their agreements. The standardized unit makes it easier to model “what-if” scenarios, which we do in the later sections.

When to use each tier — decision framework

Choosing between Sol, Terra, and Luna requires balancing quality needs, latency/throughput constraints, cost goals, and engineering effort. Below is a pragmatic decision framework suitable for product and engineering teams to make durable choices.

Framework — step-by-step

1. Define success metrics: accuracy, latency (p95), cost per user/month, and SLA targets.
2. Categorize workload by complexity:
   • High-complexity (multi-step reasoning, legal, academic synthesis) → evaluate Sol
   • Moderate-complexity (summaries, customer support answers, in-product assistants) → evaluate Terra
   • Low-complexity (classification, short responses, telemetry tagging) → evaluate Luna
3. Estimate token volume per unit of work (prompt + expected response length + retained context).
4. Run a cost-quality test: sample 500–1,000 requests on Sol/Terra/Luna. Measure error rates, hallucination frequency, and latency.
5. Apply budget and SLA constraints — pick the lowest-cost tier that meets your success metrics. Consider hybrid routing (Sol for critical, Terra for general, Luna for high-throughput).
6. Plan for fallbacks: if Sol is unavailable or near quota, degrade to Terra with reduced context to maintain service uptime.

This framework produces an operational implementation pattern: default to Terra for user-facing experiences, route high-value requests to Sol, and send non-critical, high-volume tasks to Luna. Hybrid routing reduces average cost while preserving quality where it matters.

For a deeper exploration of related concepts, our comprehensive article on The Complete AI Tools Stack for 2026: 10 Tools Evaluated provides detailed analysis and practical frameworks that complement the strategies discussed in this section.

Detailed cost optimization techniques

Even with tier selection, teams must actively optimize costs. Below are practical, implementable strategies with examples and code where appropriate.

1) Token budgeting and prompt engineering

Token costs are linear in consumption. Reducing prompt length and optimizing the expected response length are immediate levers.

• Compress prompts: replace long natural-language instructions with compact structured prompts or templates.
• Use few-shot judiciously: instead of providing many examples, use a single well-chosen example or use a stored pattern in memory and refer to it.
• Constrain outputs: set clear max_tokens or use stop sequences to prevent runaway responses.

# Example: concise prompt template vs verbose prompt
# Python pseudo-code for token budgeting
def build_prompt(user_question, short_instructions=True):
    if short_instructions:
        system = "You are a concise assistant. Answer in under 60 words."
    else:
        system = ("You are an assistant that follows these rules:\n"
                  "- Provide detailed context\n- Offer three examples\n- Explain step-by-step")
    prompt = f"{system}\nUser: {user_question}"
    return prompt

In tests, cutting redundant text from a system instruction can reduce prompt tokens by 30–60% depending on how verbose earlier instructions were.

2) Caching and memoization

Cache both inputs and outputs for idempotent queries. For example, a product description summarizer that receives repeated SKUs should return cached summaries rather than re-invoking the model.

• Cache keys: use deterministic keys derived from normalized inputs (lowercase, trimmed spaces, normalized punctuation).
• Cache TTLs: choose TTLs based on data freshness requirements; many applications use long TTLs for static content and short TTLs for user messages.
• Store both raw and tokenized forms: store the tokenized prompt length to avoid re-tokenizing for cost estimation.

# Example: pseudo-code for caching a summary
def get_summary(sku):
    key = f"summary:{normalize(sku)}"
    cached = redis.get(key)
    if cached:
        return cached
    prompt = build_prompt(f"Summarize product {sku}", short_instructions=True)
    response = openai.client.create(model="gpt-5.6-terra", prompt=prompt, max_tokens=120)
    redis.set(key, response.text, ex=60*60*24*30)  # cache 30 days
    return response.text

3) Response truncation and streaming

Streaming responses and early stop criteria can reduce the number of produced tokens. Use max_tokens conservatively and monitor p95 output lengths to set reasonable bounds. If users rarely need more than 80 tokens, set max_tokens=100 to avoid paying for rare tail events.

4) Batched and multi-completion requests

When processing many small tasks (for example, embedding or classification of many records), batch inputs into a single request where possible. Batching reduces per-request overhead and can reduce overall prompt duplication.

# Example: batching multiple short items into single request
items = ["text one", "text two", "text three"]
prompt = "Classify the following items into categories:\n"
for i, item in enumerate(items, 1):
    prompt += f"{i}. {item}\n"
response = openai.client.create(model="gpt-5.6-luna-classify", prompt=prompt, max_tokens=50)

5) Smart routing across tiers

Implement a tier-routing layer:

• Start with Terra for a request.
• If Terra’s confidence metric or heuristic indicates low quality, re-run on Sol (caching both requests to avoid duplication).
• Use Luna for low-cost pre-processing steps, such as extracting entities that are then passed to Terra for reasoning.

Smart routing reduces average cost while maintaining fallbacks for quality. The routing logic can be implemented as a lightweight decision service.

For a deeper exploration of related concepts, our comprehensive article on The Complete Guide to GPT-5.5’s Four Model Tiers: Base, Pro, Instant Mini, and When to Use Each provides detailed analysis and practical frameworks that complement the strategies discussed in this section.

6) Embeddings and reuse

When semantic similarity or retrieval augmented generation (RAG) is needed, use embeddings + vector store to retrieve condensed context rather than sending entire documents to the model. Retrieve only top-K passages and use summarization to further compress context.

# Example: rough retrieval pipeline flow
query_embedding = embeddings.encode(query_text)
doc_ids = vector_store.search(query_embedding, top_k=5)
context = "\n".join([summaries[id] for id in doc_ids])  # use precomputed summaries
prompt = f"Use the context to answer:\n{context}\nQuestion: {query_text}"

7) Monitor and alert on credit consumption

Instrument per-endpoint and per-team credit consumption. Use daily rolling windows and set alerts for anomalies. This prevents surprise spikes and enables immediate throttling to protect budgets.

Enterprise plans: Business, Enterprise, Edu, Health, Gov

OpenAI offers differentiated enterprise plans tailored to compliance, data residency, and support requirements. These plan types commonly adjust SLA, compliance certification, contract terms, and price negotiation. Below is a practical breakdown of typical differences organizations encounter:

Price negotiation and credit-to-USD conversion are typically more flexible at the Enterprise and Gov levels, including committed spend discounts, custom invoicing cycles, and reserved capacity (useful for predictable high-volume inference).

For a deeper exploration of related concepts, our comprehensive article on The Big Model Comparisons Story: What July 09’s News Means for Developers provides detailed analysis and practical frameworks that complement the strategies discussed in this section.

Billing and practical tips for teams

• Use separate API keys per environment (dev/staging/prod) to isolate cost and track usage.
• Enable alerts for high credit consumption on account and per-project levels.
• Reserve capacity or negotiate committed spend if you need predictable unit economics.
• Leverage multi-product credit drawing: features like Codex and ChatGPT Work draw from the same credit pool, so plan shared-budget scenarios accordingly.

Codex, ChatGPT Work, ChatGPT for Excel: shared credit pool implications

One important operational detail: Codex (code generation), ChatGPT Work, and ChatGPT for Excel all draw credits from the same centralized account credit pool. That means:

• Using an automated code-generation pipeline (Codex) can consume credits that would otherwise be allocated for user-facing chat sessions.
• Administrators must monitor cross-product consumption and create quotas or separate accounts if needed to prevent one use-case from starving others.
• For enterprise customers, negotiated agreements can specify allocation buckets, but without explicit allocations, credits are fungible across OpenAI products.

Real-world cost scenarios: worked examples

This section provides concrete monthly cost projections under reasonable assumptions for different organization sizes. All numerical results use credits as the base unit; example USD conversions are illustrative. Before committing, always pilot with your real traffic pattern and measure median token sizes.

Assumptions common to all scenarios

• 1 token ≈ 0.75 English words (for conversion intuition).
• Credit-to-USD conversion is illustrative; replace with your negotiated conversion.
• We assume the following per-1M-token rates in credits (rounded): Sol: 1,200; Terra: 300; Luna: 45.
• Setup: prompt is 60 tokens average; response is 120 tokens average; retained context per active user is 300 tokens (where applicable).

Scenario A — Startup (10K monthly active users)

Use case: in-app assistance with short Q&A. Default routing: Terra for 80% of requests, Luna for 20% (simple requests). Average tokens per request: prompt 60, response 100.

Credits consumed:

• Terra: 80,000 requests × 160 tokens = 12,800,000 tokens → 12.8 × (300 credits / 1M) = 3,840 credits
• Luna: 20,000 requests × 160 tokens = 3,200,000 tokens → 3.2 × (45 credits / 1M) = 144 credits
• Monthly total credits ≈ 3,984 credits

Example USD conversion (illustrative): if 1,000 credits = $1.00 USD, cost ≈ $3.984 per month. In practice, credit-to-USD exchange will vary; the real takeaway is that mixed routing dramatically lowers cost versus running everything on Sol.

Scenario B — Mid-size company (500K monthly active users)

Use case: customer support with longer context and occasional escalation. Default routing: Terra 70%, Sol 10% escalations, Luna 20% for quick metadata tasks. Average tokens: prompt 120, response 180, retained context (for escalations) 600 tokens.

Credits consumed (rounded):

• Terra: 3,500,000 × 300 tokens-per-M? — compute tokens: 3.5M × 300 tokens-per-request? (Note: tokens per request are 300 = prompt 120 + response 180) → 1,050,000,000 tokens ≈ 1,050 × (300 credits / 1M) = 315,000 credits
• Sol: 500,000 requests × (120+180=300 tokens) = 150,000,000 tokens → 150 × (1,200 credits / 1M) = 180,000 credits
• Luna: 1,000,000 × 300 tokens = 300,000,000 tokens → 300 × (45 credits / 1M) = 13,500 credits
• Monthly total credits ≈ 508,500 credits

Example USD conversion: if 10,000 credits = $5.00 USD, monthly cost ≈ (508,500 / 10,000) × $5 = $254.25 × 5? (Make sure to replace with your contract’s credit-to-USD rate.) The key point is that Sol escalations materially increase cost; careful triage and escalation thresholds profoundly impact monthly spend.

Scenario C — Enterprise (50M monthly active events)

Use case: mixed product features — enterprise search, long-document summarization, and real-time chat. Hybrid routing with advanced caching, heavy use of embeddings, and reserved Sol capacity for high-value tasks.

Because enterprise deals often include reserved capacity and negotiated credit rates, the effective credits per 1M tokens and the credit-to-USD conversion are frequently optimized. This makes exact numbers less meaningful without the negotiated terms. The right approach is to model expected token volume, then negotiate a committed credit tier.

Practical examples: implement cost calculation in your app

Below are code snippets to help engineering teams estimate costs programmatically. They compute credit consumption for a request and allow you to simulate monthly totals.

# Python: simple cost estimator (credits)
def estimate_request_credits(model_rate, prompt_tokens, response_tokens, context_tokens=0):
    """
    model_rate: dict with keys 'prompt', 'response', 'context' (credits per 1_000_000 tokens)
    returns credits consumed for single request
    """
    prompt_credits = prompt_tokens * (model_rate['prompt'] / 1_000_000)
    response_credits = response_tokens * (model_rate['response'] / 1_000_000)
    context_credits = context_tokens * (model_rate.get('context', 0) / 1_000_000)
    total_credits = prompt_credits + response_credits + context_credits
    return total_credits

# Example rates for Terra
terra_rate = {'prompt': 300, 'response': 300, 'context': 1200}
print(estimate_request_credits(terra_rate, prompt_tokens=120, response_tokens=180))

The above returns credits per request; multiply by monthly requests to forecast monthly consumption. Add a buffer (10–25%) for growth and edge cases.

Advanced design patterns for cost control

Beyond the basic techniques, advanced design patterns yield further savings with modest engineering effort.

1) Tiered quality lanes

Implement lanes: “economy”, “standard”, and “premium”. Assign default lane for each user type; upgrade only when user action or payment indicates premium access.

2) Token-aware load shedding

When you hit a quota or burst, shed requests that are likely to be expensive (long context or long expected responses) and serve a simpler response instead.

3) Cost-aware retries and backoff

Do not blindly retry expensive requests; instead, re-route to a lower-tier model with a truncated prompt or use cached result with an explanation to the user that a lighter answer is being returned.

4) Auditing and explainability for high-cost requests

For high-cost requests (identified by token length or Sol-tier use), store a small audit record including prompt length and reason for escalation. Use this for budget reviews and prioritization.

Governance: quotas, teams, and showback

Design a governance model that includes:

• Per-team quotas with soft/hard limits and alerting.
• Monthly showback reports summarizing credit usage by product feature and by tier (Sol/Terra/Luna).
• Cost ownership: product managers sign off on credit allocations for experiments.

Implementation checklist for migrating to GPT-5.6 pricing

• Inventory all endpoints that call OpenAI APIs and estimate average tokens per call.
• Map endpoints to a target tier (Sol/Terra/Luna) based on quality and latency needs.
• Integrate a cost-estimator and preflight check in your gateway to reject requests exceeding budget per request.
• Implement caching and vector-store retrieval for data-heavy contexts.
• Monitor usage and set automated alerts for spikes.
• Negotiate enterprise terms if predictable high volume is expected.

Common pitfalls and how to avoid them

Pitfall: underestimating context costs

Long-term memory features can accumulate context token costs. Track both active and archival context size and budget separately for retained context charges.

Pitfall: stake everything on Sol

Running all requests on Sol is expensive and unnecessary in many cases. Adopt the routing strategies above to keep average cost manageable.

Pitfall: ignoring tail latency and retry amplification

Retries on timeouts can amplify cost. Implement idempotency keys, exponential backoff, and cost-aware retries to reduce waste.

Security and compliance considerations

When choosing tiers and enterprise plans, security and compliance are often decisive. For Health and Gov plans, ensure that data handling, logging, and residency meet your regulatory obligations. Use dedicated keys per environment, rotate keys regularly, restrict IPs, and consider bring-your-own-key (BYOK) where available.

Support and SLA expectations

SLA and support vary by plan. Enterprise customers get prioritized support and faster incident response. For production services, aim to negotiate an SLA that matches your uptime and latency requirements, including clear definitions for incident severity and response windows.

How to run a pricing pilot

Suggested pilot steps:

1. Identify 500–1,000 representative requests for your product (cover edge cases).
2. Measure token usage and quality across Sol, Terra, and Luna for the sample.
3. Compute credits-per-1K or per-request for each tier and evaluate quality metrics.
4. Test caching and batching optimizations to quantify cost savings.
5. Present a three-month forecast with conservative growth assumptions to stakeholders.

Vendor negotiation tips

• Use your pilot data to ask for committed discount tiers tied to predictable spend.
• Negotiate reserved capacity for Sol if you have mission-critical flows that cannot be interrupted or throttled.
• Ask for per-feature cost allocation tools in the billing console for better showback.
• Clarify credit expiration and rollover rules in the contract.

Appendix A: Glossary of billing terms

Appendix B: Example API call patterns and cost-aware client code

Below is an example of a small, cost-aware client that estimates credits, enforces a per-request budget, and routes to the appropriate tier.

# Pseudo-code: cost-aware request router
MODEL_RATES = {
    "gpt-5.6-sol": {'prompt': 1200, 'response': 1200, 'context': 6500},
    "gpt-5.6-terra": {'prompt': 300, 'response': 300, 'context': 1200},
    "gpt-5.6-luna": {'prompt': 45, 'response': 45, 'context': 200},
}

def select_model(required_quality, prompt_tokens, response_tokens):
    """
    required_quality: 'high' | 'standard' | 'fast'
    budget_threshold: credits per request limit (optional)
    """
    if required_quality == 'high':
        return "gpt-5.6-sol"
    elif required_quality == 'standard':
        return "gpt-5.6-terra"
    else:
        return "gpt-5.6-luna"

def estimate_and_call(required_quality, prompt_tokens, response_tokens):
    model = select_model(required_quality, prompt_tokens, response_tokens)
    rate = MODEL_RATES[model]
    est_credits = estimate_request_credits(rate, prompt_tokens, response_tokens)
    if est_credits > PER_REQUEST_MAX_CREDITS:
        # fallback to cheaper model with truncated context
        model = "gpt-5.6-luna"
        truncated_response_tokens = min(response_tokens, 80)
        est_credits = estimate_request_credits(MODEL_RATES[model], prompt_tokens, truncated_response_tokens)
    # Execute API call (pseudo)
    return api_call(model=model, prompt=build_prompt(...), max_tokens=truncated_response_tokens)

Frequently asked questions (FAQ)

Do different OpenAI products draw from the same credit pool?

Yes. Codex, ChatGPT Work, ChatGPT for Excel, and GPT-5.6 API calls (unless expressly separated by contractual terms) draw from the same account credit pool. Administrators should plan budgets accordingly and consider separate accounts for siloed teams when necessary.

How do negotiated enterprise discounts work?

Enterprises typically negotiate committed spend for a lower per-credit price, reserved capacity for Sol access, and dedicated support. Discounts may be tiered based on volume and term length and often include implementation support and feature SLAs.

Are credits transferable across accounts?

By default, credits are bound to the organization or account in which they were purchased. Transferability depends on the terms of the contract and whether OpenAI supports cross-account pooling for your agreement.

Summary and recommended next steps

Key takeaways:

• Use Sol for complex, high-value reasoning tasks; Terra as the default for most production uses; Luna for high-throughput simple requests.
• The credit-per-1M-token metric simplifies cost forecasting but requires accurate token sizing estimates.
• Optimize using prompt engineering, caching, batching, and multi-tier routing to significantly reduce average cost.
• Monitor cross-product usage (Codex, ChatGPT Work, ChatGPT for Excel) because they share the same credit pool.
• Enterprise plans offer negotiation leverage and additional compliance and SLA features; pilot data is the best leverage for negotiating committed discounts.

Next steps for teams:

1. Run a 2-week pilot measuring token sizes across critical workflows on Sol/Terra/Luna.
2. Implement a cost-estimator and per-request budget guardrail in your API gateway.
3. Set up monitoring and alerts for unexpected credit consumption spikes.
4. Use pilot data to negotiate enterprise terms if you expect significant monthly consumption.

Closing notes

This guide is designed to be a single, comprehensive resource to help engineering, product, and finance teams navigate the GPT-5.6 pricing landscape. Because billing models and negotiated terms evolve, always validate rates in your OpenAI console and your legal agreement. The practical patterns and optimizations described here are broadly applicable and will help you control cost while delivering quality experiences using Sol, Terra, and Luna.

If you want a custom worksheet that converts your logs into a per-month credit forecast, provide sample request logs and I can produce a templated calculator for your team.