GPT-5.6 (Sol/Terra/Luna) & Grok 4.5 API Pricing (2026)

July 2026 saw two flagship launches in quick succession: OpenAI’s GPT-5.6 family (Sol / Terra / Luna, generally available July 9) and xAI’s Grok 4.5 (shipped July 8, GA July 9). Leading with the rates (per 1M tokens, input / output): GPT-5.6 Sol = $5 / $30 (hard reasoning, coding, science), GPT-5.6 Terra = $2.50 / $15 (roughly GPT-5.5 quality at about half the price; the everyday workhorse), GPT-5.6 Luna = $1 / $6 (fast, low-cost, high-volume), and Grok 4.5 = $2 / $6 (500K context, OpenAI-compatible API, strong at agentic use).

The routing conclusion up front too: build the base on a mid-tier model (Terra or Grok 4.5), escalate only the steps that need Sol, and push simple, high-volume work down to Luna. Below we walk through each model, then per-use-case selection, cost optimization, and how an SMB should choose. This article reflects official and reported figures as of July 23, 2026; rates change with vendor revisions, so re-check the official docs before you build.

GPT-5.6 is not a single model but a family that holds a common generation of quality while splitting into three tiers — accuracy-first, balanced, and speed-first. The names run sun (Sol), earth (Terra), and moon (Luna); heavier and pricier at the top.

Three things stand out. (1) Terra delivers roughly the quality of the old flagship GPT-5.5 ($5 / $30) at exactly half the price, which makes it the sweet spot for most business apps. (2) Cached input is 90% off standard input on all three (Sol $0.50, Terra $0.25, Luna $0.10), so caching pays off whenever you resend a system prompt or fixed document. (3) You move between the three just by swapping the model ID, reusing the same prompt assets.

Grok 4.5 is xAI’s flagship as of July 2026: $2 input / $6 output per 1M tokens, $0.50 cached input, and a 500K-token context. The API is OpenAI-compatible, so you can call it from an existing OpenAI SDK by swapping the base URL and model name — a low-friction migration. It also exposes a reasoning-effort setting, letting you dial how much the model thinks per request and control cost accordingly.

Publicly, it is cited at 54 on Artificial Analysis’ Intelligence Index (4th overall) and 1st on agentic tool use, making it strong for autonomous workflows that call external tools while progressing through steps.

One caveat: per reporting, prompts above 200K tokens double all rates (input, cached input, and output), moving Grok 4.5 to $4 input / $12 output. The 500K window is real, but routinely sending very large prompts pushes you into that higher-cost band — worth designing around. Confirm the threshold and multiplier against the official pricing page.

Alongside these two families we add the open-weight DeepSeek V4 (covered in a recent article) and the prior flagship GPT-5.5 as reference points. All figures are per 1M tokens (USD).

The table shows a persistent ~10x rate gap between closed high-quality models and open-weight ones. Choose closed models for quality and hands-off operation; choose open-weight like DeepSeek V4 when you want to drive per-unit cost to the floor or self-host. For the hardware needed to run open-weight models yourself, see the DeepSeek V4 requirements reference. For the lineage from the prior generation, see our GPT-5.5 release breakdown.

Choosing on rate alone leads you astray. Each workload has a natural fit; here are four common patterns.

1. Coding and hard design: GPT-5.6 Sol first. For complex refactors or algorithm design, where mistakes are expensive, the top tier’s accuracy is cheapest in the end. Everyday completion is fine on Terra.
2. Agents (autonomously calling tools): Grok 4.5 is strong here — high on tool-use metrics and easy to slot into existing agent code thanks to the OpenAI-compatible API. Worth trying for long multi-step workflows.
3. Large batches and lightweight jobs: GPT-5.6 Luna or DeepSeek V4-Flash. For summarize/classify/tag work — many items, each light — the per-token rate directly drives the total. Open-weight is cheapest if quality allows.
4. Sensitive data: Terms before rate. Confirm no-training-use, retention, and region; if self-hosting is required, running an open-weight model like DeepSeek V4 in your own environment is an option.

Even with the same model, usage can swing effective cost several-fold. Three levers, in order of impact.

Prompt caching: put the "same front half every time" — system prompt, long reference doc — into the cache. GPT-5.6 is 90% off standard input; Grok 4.5 is $0.50 / 1M cached. It fits RAG-style setups (fixed prefix, variable tail) especially well and compresses the main driver of input cost.
Model routing: don’t serve everything from one model. Base on a mid-tier (Terra / Grok 4.5), send only hard steps to Sol, and push simple work to Luna or DeepSeek. A tiered "try cheap first, re-ask the top tier only when confidence is low" design also works.
Reasoning-effort tuning: on models that expose it, set effort low for easy work and high for hard decisions. Leaving it maxed everywhere means paying premium reasoning cost on trivial tasks.

These stack. "Base on Terra, cache the fixed parts, route easy calls to Luna" alone cuts effective cost well below naively staying on Sol.

The answer: pick one mid-tier model and measure it on your real prompts for a week or two before scaling. Running everything on the top tier makes cost unpredictable; the cheapest model alone tends to force rework on quality.

Need the OpenAI ecosystem / broad quality → start from GPT-5.6 Terra, escalate only where needed to Sol.
Cost-sensitive / agent- and tool-centric → Grok 4.5 (OpenAI-compatible, so re-hosting is light).
Minimize per-unit cost / want self-hosting → open-weight like DeepSeek V4 (but you own the ops and hardware).
Handling sensitive data → check terms (no-training-use, retention, region) before rate.

In every case, surface token consumption and per-task cost on a monthly dashboard, learn which steps eat the budget, then tighten routing — the apparent detour is the fastest path. Because models keep updating on a months-long cadence, avoid tightly coupling your code to one model; keep the model ID easy to swap.