Skip to content
Climb Google Maps: Google Business Profile optimization.

Automation

GPT-6.2 Astra and Sol Are Out: 20% Cheaper Astra, Same-Price Sol. What a Whole-Site AI Job Now Costs

OpenAI released GPT-6.2 Astra and GPT-6.2 Sol on Nov. 17 in ChatGPT Work, Codex and the API. Astra's API price fell from $10 and $50 to $8 and $40 per million tokens. We ran a free script over our own sitemap to price one AI job across every page on each model.

Rows of rack servers with blue indicator lights in a data center

Key takeaways

  • GPT 6.2 Astra and GPT 6.2 Sol launched on Nov. 17, 2026, in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users and in the OpenAI API as gpt-6.2-astra and gpt-6.2-sol.
  • GPT-6.2 Astra costs $8 per million input tokens and $40 per million output tokens on the API, down from $10 and $50 for GPT-6 Astra; GPT-6.2 Sol stays at $2 and $10.
  • Both models have a 1,050,000 token context window and 128,000 max output tokens, and input over 272,000 tokens doubles the input price.
  • Our script priced one job over all 108 pages of thesearchpost.com's sitemap (about 311,000 input tokens): $4.65 on GPT-6.2 Astra, $1.16 on GPT-6.2 Sol and $5.81 on GPT-6 Astra at Standard rates, and half that on Batch.
  • Developers moving to GPT-6.2 should move reusable instructions into a developer message to keep prompt caching, and use the Responses API for tool calls such as web search.

OpenAI released GPT 6.2 in two sizes on Nov. 17, 2026: GPT-6.2 Astra, its model for the hardest work, and GPT-6.2 Sol, its everyday model. Both are in ChatGPT Work and Codex for paid plans and in the API today. For anyone who uses OpenAI's API on a website, the headline is price: Astra now costs $8 per million input tokens and $40 per million output tokens, down from $10 and $50 for GPT-6 Astra, and Sol stays at $2 and $10.

Prices per million tokens are hard to picture, so we wrote a short script that reads a sitemap and prices one AI job across every page on each model. On our own site, the whole job costs $1.16 on Sol and $4.65 on Astra.

Who can use GPT 6.2 in ChatGPT?

According to OpenAI's announcement, as posted by a staff member in its developer forum and reported by 9to5Mac, both models are available in ChatGPT Work and Codex for Plus, Pro, Enterprise and Edu users. Neither source mentions free users or the regular ChatGPT chat, and neither names countries, so expect availability to follow your plan and workspace settings rather than your location. Ultrafast mode comes with Sol on the $200 Pro plan and with both models on the $500 Pro plan.

Nothing in OpenAI's material says GPT-6.2 now powers ChatGPT search answers, so there is no sign yet that which pages ChatGPT cites will change because of this launch. Our guide to how to get cited by ChatGPT still applies.

How much does GPT 6.2 cost on the API?

From OpenAI's model pages, Standard tier, per million tokens:

ModelInputCached inputOutputKnowledge cutoff
GPT-6.2 Astra$8$0.40$40May 18, 2026
GPT-6.2 Sol$2$0.10$10June 1, 2026
GPT-6 Astra (previous)$10$1$50April 30, 2026

The rules that move the bill:

  • Long prompts cost more. Over 272,000 input tokens, input and cache rates double and output costs 1.5 times as much for the whole request. Both models accept up to 922,000 input tokens in a 1,050,000 token context window, with up to 128,000 output tokens.
  • Waiting is cheaper. Batch is half price. A new background mode in the Responses API, in public beta since Nov. 17, cuts token rates by 30% if you accept answers within two hours and 40% within eight hours.
  • Speed costs more. Fast mode is twice the Standard rate. Ultrafast is three times Standard through Feb. 28, 2027, then six times from March 1, 2027.
  • Data residency. OpenAI's guide says both models support US and EU data residency on Standard, Fast and Batch; Ultrafast is US only.

What does one AI job across a whole site cost?

Our test: we pointed the script below at thesearchpost.com's sitemap on Nov. 18 at 18:43 UTC (1:43 p.m. Eastern). It read all 108 pages, stripped the HTML to plain text and estimated tokens with OpenAI's own rule of thumb (about 4 characters of English per token). We added 300 tokens of instructions per page and allowed 500 output tokens per page, which covers a short answer such as a new meta description plus some reasoning. Reasoning tokens bill as output, and how many a model uses varies by task, so treat the output figure as an allowance we chose, not a measurement.

Result: about 311,162 input tokens (2,881 a page) and 54,000 output tokens.

ModelStandardBackground, 2 hoursBackground, 8 hoursBatch
GPT-6.2 Astra$4.65$3.25$2.79$2.32
GPT-6.2 Sol$1.16$0.81$0.70$0.58
GPT-6 Astra$5.81not offerednot offered$2.91

The script, for Node.js 18 or later (no packages needed):

// gpt-cost.mjs: estimate one AI job over every page in a sitemap.
// Usage: node gpt-cost.mjs https://example.com/sitemap.xml [outputTokensPerPage] [promptTokens]
// Prices: OpenAI API model pages, per 1M tokens, Standard tier, short context (Nov. 17, 2026).
const PRICES = {
  'gpt-6.2-astra': { input: 8, output: 40 },
  'gpt-6.2-sol': { input: 2, output: 10 },
  'gpt-6-astra': { input: 10, output: 50, noBackground: true },
};
// Batch is 50% of Standard; background windows are 30% (2h) and 40% (8h) lower.
const MODES = { standard: 1, 'background 2h': 0.7, 'background 8h': 0.6, batch: 0.5 };
 
const [sitemap, outArg = '500', promptArg = '300'] = process.argv.slice(2);
const OUTPUT_PER_PAGE = Number(outArg); // answer plus reasoning, both billed as output
const PROMPT_TOKENS = Number(promptArg); // your instructions, sent with every page
 
// OpenAI's rule of thumb: 1 token is about 4 characters of English text.
const tokens = (text) => Math.ceil(text.length / 4);
const pageText = (html) =>
  html
    .replace(/<(script|style|noscript|svg)[\s\S]*?<\/\1>/gi, ' ')
    .replace(/<[^>]+>/g, ' ')
    .replace(/&[a-z#0-9]+;/gi, ' ')
    .replace(/\s+/g, ' ')
    .trim();
 
const xml = await (await fetch(sitemap)).text();
const urls = [...xml.matchAll(/<loc>\s*([^<\s]+)\s*<\/loc>/g)].map((m) => m[1]);
 
let inputTokens = 0;
let pages = 0;
for (const url of urls) {
  try {
    const res = await fetch(url, { headers: { 'User-Agent': 'gpt-cost-estimator' } });
    if (!res.ok) continue;
    inputTokens += PROMPT_TOKENS + tokens(pageText(await res.text()));
    pages++;
  } catch {
    // skip pages that fail to load
  }
}
const outputTokens = pages * OUTPUT_PER_PAGE;
console.log(`${pages} pages, ~${inputTokens} input tokens, ${outputTokens} output tokens`);
 
const rows = Object.entries(PRICES).map(([model, p]) => {
  const base = (inputTokens / 1e6) * p.input + (outputTokens / 1e6) * p.output;
  const row = { model };
  for (const [mode, factor] of Object.entries(MODES)) {
    row[mode] = p.noBackground && mode.startsWith('background') ? 'n/a' : `$${(base * factor).toFixed(2)}`;
  }
  return row;
});
console.table(rows);

If your sitemap is an index file that lists other sitemaps, run it once per child sitemap. Pages with lots of text, such as long product descriptions, cost more than our news posts; the per-page token count in the output tells you where you stand. It does not include tool fees: OpenAI's pricing page lists web search at $10 per 1,000 calls plus the search content tokens.

What changes for developers?

From OpenAI's changelog and migration guide:

  • Tool calls need the Responses API. Both models work in Chat Completions, but tools such as web search, file search and computer use require Responses.
  • Prompt caching moved. GPT-6.2 appends the top-level instructions field after the input, so long, reusable instructions (a style guide, a brand voice) only cache if you put them in a developer message at the start of input. On a job like ours, that is the difference between paying $8 and $0.40 per million tokens for the instructions on Astra.
  • Reasoning effort. The API rejects none. OpenAI suggests medium for a new integration and low if you used none or minimal before.
  • Dropped parameters. Omit temperature, top_p and top_logprobs when migrating.
  • Writing is shorter by default. OpenAI's guide says Astra writes "more concise and direct by default," so revisit any "be concise" line in an existing prompt.

Our view: Sol for volume, Astra for the hard jobs

For marketing and website work that runs over many pages (meta descriptions, alt text, internal link suggestions, content audits), start with GPT-6.2 Sol on Batch or the eight-hour background window. On our site that whole job is under a dollar. Keep Astra for long, hard tasks where a mistake is expensive: a site migration plan, a messy codebase, a multi-step agent run. That is the same split we suggested for Claude Fable 5.2, which now sits at exactly the same API price as GPT-6.2 Astra, $8 and $40.

If you already run GPT-6 Astra jobs, switching to GPT-6.2 Astra is a straight 20% cut on input and output rates and a 60% cut on cached input, before any change to how many tokens the model uses.

What we don't know yet

  • Independent benchmarks. OpenAI's own claims, from the copy of its announcement a staff member posted in its developer forum: Astra sets new highs on professional and scientific evaluations "at less than a third of the cost per task" of GPT-6 Astra, and on FrontierCode 2.0 Sol "nearly matches Astra" on merge-ready code changes at about one-fifth the cost. Those are OpenAI's numbers, not tests we ran, and our script prices tokens, not tasks.
  • Regular ChatGPT. Whether and when GPT-6.2 reaches the standard ChatGPT chat and free users has not been announced in anything we read.
  • Reasoning tokens. How many reasoning tokens each model spends on a typical SEO task decides the real bill. We haven't run either model yet; this site runs on Claude, as we explain in how we run an AI news desk.

Sources

Photo of Kiran Dasgupta

About the author

Kiran Dasgupta, Editor

Kiran runs Kihan Marketing, a web design, SEO and ads agency, and manages dozens of websites across real estate, home services and healthcare. He writes about SEO, AI search and paid ads news, and what it means for the people who run websites.