GPT-6.1 API Guide: Sol, Terra, Astra and Luna Compared

GPT-6.1 is now two models in the OpenAI API, and the naming makes it easy to pick the wrong one. GPT-6.1 Sol arrived on 29 September 2026 and GPT-6.1 Terra on 26 October, while the flagship is still GPT-6 Astra and the cheapest tier is still GPT-6 Luna. In this guide I lay out what each model is for, what it costs per task, how it compares with Claude Opus 5.5, and what to change in your code when you move to it. Every price and limit here comes from OpenAI's own docs, checked on 29 October 2026.

The GPT-6.1 family at a glance

OpenAI's GPT-6 guide groups the current models into four tiers. Two of them carry the 6.1 version number. The other two are still the original GPT-6 releases.

All four share the same limits: a 1,050,000 token context window, 922,000 maximum input tokens, 128,000 maximum output tokens, text and image input, and text output. All four work with the Responses, Chat Completions and Batch endpoints. Release dates come from the API changelog and specs from the model pages for Terra, Sol, Astra and Luna.

GPT-6.1 Sol: the coding and agent model

OpenAI describes GPT-6.1 Sol as "near-Astra intelligence for a fifth of the price". It is the upgrade to GPT-6 Sol for complex coding, computer use and professional work. The input and output prices stayed the same as GPT-6 Sol ($2 and $10), but cached input dropped from $0.20 to $0.10 per million tokens. If your agent resends a long system prompt and tool list on every turn, that cache discount is the part you will notice on the bill.

The vendor-reported results are worth reading as direction, not as a promise for your workload. OpenAI says GPT-6.1 Sol matches GPT-6 Astra on DeepSWE v1.1 at roughly one-fifth of the cost, and that on Terminal-Bench Science it averaged $5.47 per task against $23.21 for Opus 5.5 and $23.80 for Astra. The same post still recommends Astra for the most difficult scientific research tasks.

Two practical details matter for developers:

• GPT-6.1 Sol does not accept reasoning.effort: "none". GPT-6 Sol did. Use low instead.
• It supports Multi-agent in beta, where the model delegates work to subagents inside one Responses API request, and an Ultrafast service tier ($12 / $60 per million tokens) was added on 8 October.

GPT-6.1 Terra: the cheap workhorse for vision, screens and writing

GPT-6.1 Terra is the newest release and the one most teams should test first. OpenAI pitches it for visual reasoning, precise computer use and clear writing: matching product photos to catalogue entries, interpreting technical drawings, acting on application screens, and drafting text. At $1 input and $5 output it is half the price of GPT-6.1 Sol and of GPT-5.6 Terra before it.

Compared with GPT-5.6 Terra ($2 / $12, cached $0.20), that is 50% off input, about 58% off output and 75% off cached input. OpenAI also reports that at medium effort it scores 15 points higher than GPT-5.6 Terra on its Agents' Last Exam benchmark at about one-third of the cost, and that its error rate on a set of error-inducing prompts fell from 53.6% to 16.7% at low effort. Those are OpenAI's own measurements.

OpenAI is clear about where Terra stops: "For the most complex coding tasks, GPT-6.1 Sol and GPT-6 Astra remain the better choice."

Is there a GPT-6.1 Astra or GPT-6.1 Luna?

Not yet. Search interest for "gpt-6.1 astra" is real, but the API has only gpt-6-astra, released on 3 September 2026 as OpenAI's most capable model at $10 / $50 per million tokens. Luna is the same story: gpt-6-luna (22 September) is the current small model at $0.10 / $0.50, and on 22 October it became the model behind the generally available Decisions API. If a tutorial or tool lists "gpt-6.1-astra" as a model ID, the request will not match any model on OpenAI's docs today.

GPT-6.1 vs Opus 5.5

Anthropic lists Claude Opus 5.5 at $4 input and $20 output per million tokens, with cache reads at $0.20, a 1M token context window and 128K max output. On list price per token:

• GPT-6.1 Terra is a quarter of Opus 5.5 on both input and output.
• GPT-6.1 Sol is half of Opus 5.5 on both.
• GPT-6 Astra is 2.5x Opus 5.5.

OpenAI claims Terra at max effort costs about 9x less per task than Opus 5.5 because it also uses fewer tokens, and that Sol beats Opus 5.5 on its GDP.pdf and AutomationBench evaluations. I have not run these comparisons myself, so treat them as a reason to test, not a conclusion. If you are already on Claude, my Claude Sonnet 5.5 vs Opus 5.5 guide covers Anthropic's side of the choice.

What a task costs: an invoice extraction example

Per-token prices only mean something once you put a task behind them. Take a common workload: reading an invoice image and returning structured fields. Assume each task sends 2,000 fresh input tokens (the image and invoice text), reuses a 2,000 token cached system prompt and schema, and returns 600 output tokens including reasoning.

For this kind of job I would start with Terra, check accuracy on a sample, and only move hard documents to Sol. For a full comparison across providers, see my LLM API pricing compared per task post.

A type-checked routing example with the OpenAI SDK

This TypeScript sketch routes each task type to a model and estimates the cost from the usage block of the response. I type-checked it against openai 6.49.0 with TypeScript in strict mode. I did not make live API calls for this post.

import OpenAI from "openai";

// Standard prices per 1M tokens, prompts up to 272K input tokens
// (OpenAI pricing page, checked 29 Oct 2026).
const PRICES = {
  "gpt-6-astra":   { input: 10.0, cached: 1.0,  output: 50.0 },
  "gpt-6.1-sol":   { input: 2.0,  cached: 0.10, output: 10.0 },
  "gpt-6.1-terra": { input: 1.0,  cached: 0.05, output: 5.0 },
  "gpt-6-luna":    { input: 0.10, cached: 0.01, output: 0.50 },
} as const;

type ModelId = keyof typeof PRICES;
type Task = "classify" | "extract" | "write" | "screen" | "code" | "hardest";

// My starting map from task type to model. Tune it with your own evals.
function pickModel(task: Task): ModelId {
  switch (task) {
    case "classify":
      return "gpt-6-luna";
    case "extract":
    case "write":
    case "screen":
      return "gpt-6.1-terra";
    case "code":
      return "gpt-6.1-sol";
    case "hardest":
      return "gpt-6-astra";
  }
}

export function estimateCostUSD(
  model: ModelId,
  usage: { input: number; cachedInput: number; output: number },
): number {
  const p = PRICES[model];
  const fresh = usage.input - usage.cachedInput;
  return (fresh * p.input + usage.cachedInput * p.cached + usage.output * p.output) / 1_000_000;
}

const client = new OpenAI(); // reads OPENAI_API_KEY

export async function run(task: Task, prompt: string) {
  const model = pickModel(task);
  const response = await client.responses.create({
    model,
    // Astra and 6.1 Sol reject "none", so "low" is the safe floor for all four.
    reasoning: { effort: task === "classify" ? "low" : "medium" },
    input: prompt,
    // No temperature or top_p: they are not accepted when effort is not "none".
  });

  const u = response.usage;
  const cost = u
    ? estimateCostUSD(model, {
        input: u.input_tokens,
        cachedInput: u.input_tokens_details.cached_tokens,
        output: u.output_tokens, // includes reasoning tokens
      })
    : 0;

  return { model, text: response.output_text, costUSD: cost };
}

Logging model and costUSD per request gives you real cost-per-task numbers within a day, which beats any estimate in a table.

Migration checklist for GPT-6.1

These points come from the migration quickstart in OpenAI's GPT-6 guide and the model pages. Work through them before switching a production model ID.

• Pick the target by task, not by version number. Terra for vision, screens, forms and writing; Sol for complex coding and agents; Astra only where your evals show Sol falling short.
• Fix reasoning effort. Moving from GPT-6 Sol to GPT-6.1 Sol, replace none with low. If you used minimal, start with low. In Chat Completions the field is reasoning_effort.
• Remove sampling parameters. When effort is not none, drop temperature, top_p and top_logprobs, plus logprobs in Chat Completions.
• Move tool calls to the Responses API. Astra, 6.1 Sol and 6.1 Terra accept Chat Completions, but tool calling requires Responses.
• Update prompt caching if you come from GPT-5.5 or earlier: replace prompt_cache_retention with prompt_cache_options.ttl set to "30m", and budget for cache-write charges.
• Check data residency. Fast mode supports EU data residency for 6.1 Sol, 6.1 Terra and 6 Luna, but not for 6 Astra or 6 Sol.
• Rerun your evals at the same effort. OpenAI's own advice for GPT-5.6 Terra users is to compare both models on representative images and workflows using the same reasoning effort.
• Set a spend limit on the project before a wide rollout, then compare cost per task from real usage data after the first day.

Which GPT-6.1 model I would start with

For most app features I build (document extraction, support replies, form filling, screen automation), I would start on GPT-6.1 Terra at medium effort and keep GPT-6 Luna for classification and routing in front of it. GPT-6.1 Sol earns its higher price on multi-file coding work and long agent runs. Astra is the escalation path for the small share of tasks where both fail your checks. OpenAI has shipped four models in this family since September, so I will update this post when OpenAI ships the next model in the line.