GPT-6 Astra: pricing, real costs and when it is worthwhile

The price list of GPT-6 Astra read in thirty seconds: $10 per million tokens in input, 50 in output. The real account, however, is another thing: between repeated system prompts at each call, reasoning tokens billed as output and the threshold that doubles the rate, the difference between the quote and the invoice can be several times.

This page lines up the official price list, the items that the price list does not contain and the cases where for a company the expense is really justified. Verified data on September 4, 2026.

The complete price list

Two immediate observations. The first: the output costs five times the input, therefore a system that generates long answers spends much more than a concise one, on the same model. The second: the Reading cache costs a tenth, which is a very aggressive discount.

Cache writing, however, costs more than normal input: 12.50 versus $10, i.e. 1.25 times the unstored rate. It means that memorizing only pays off if that content is reused more than once.

The threshold of 272,000 tokens

It is the detail that ruins the most estimates and is written in one line in the documentation.

Prompts that exceed 272,000 input tokens are billed at double for input and cache and a once and a half in output. The surcharge applies to the whole request, not just the part that exceeds the threshold.

The practical consequence is brutal: a 271,000 token request costs one thing, a 273,000 one costs twice as much input. There is no graduality.

Those who pass long documents, entire archives or conversations with very historical can pass that threshold without realizing it. And since the declared window is 1,050,000 tokens, it is technically possible to stay four times above the threshold by staying within the limits of the model.

Batch, Flex and Fast mode

The documentation indicates three ways to change the account.

Batch and Flex costing the 50% Standard rates. They are designed for processes that can wait: night processing, enrichment of archives, periodic analysis, retroactive classification.

Fast mode offers up to double the speed to double the price applicable.

Many business systems contain both and treat them the same, because it was easier to build them that way. Separating the two flows allows the non-urgent part to be sent on the halved plane: it is a saving that costs nothing in terms of result.

What the price list does not contain

As with any model, the price per token is the floor of the expense. On Astra there are three items that weigh in particular.

The reasoning tokens. The model exposes five processing levels, and the intermediate tokens count as output —that is, at the $50 entry. Raising the level on a model of this range is the decision with the greatest economic impact.

The repeated system prompt. You pay for every call. Out of 20,000 monthly requests, every thousand instruction tokens are 20 million input tokens per month: $200 just to repeat the same text — unless you use the cache.

Failed attempts. Any call that does not produce a usable result is still paid for.

Traffic limits

The documentation shows thresholds that grow with the account level. It is worth knowing them before designing a high volume system, because they are a real constraint.

The level rises automatically with the use and expense accumulated. For a project that starts from scratch it means that the first few days are worked within tight limits: it must be taken into account in planning a migration or a launch, especially if you plan to process a bulk historical archive.

The Five Voices of Real Cost

The last two lines do not appear in any quote and are the ones that decide if a project makes sense.

The system prompt, multiplied

The instructions that govern the behavior of the model are paid to every single call.

Out of 20,000 monthly requests, every thousand instruction tokens are 20 million input tokens per month: $200 only to repeat the same text. With a prompt of 3,000 tokens become 600.

However, here is the most effective countermeasure available on this model: the cache. The input read from the cache costs 1 dollar instead of 10, i.e. one tenth. On a stable system prompt reread thousands of times, the difference is an order of magnitude.

The reasoning tokens

On Astra this is the fastest growing entry, because the five effort levels produce very different amounts of intermediate tokens, all counted as output at $50 per million.

An example with 20,000 monthly requests, 3,000 token input, and 500 visible response.

Multipliers are indicative and should be measured on their own case, but the direction is certain: the same request can cost ten times as much changing a parameter.

Instead, the input remains constant at $600 in all scenarios. On a model where the output costs five times the input, the level of reasoning is the main economic lever — the detail is in the five levels of reasoning.

People's Time

It is the voice that no one puts in advance and that almost always exceeds all the other put together.

If every outcome requires two minutes of human control, out of 20,000 cases per month are over 660 hours. Compare them to any digit on this page: there is no comparison.

A counterintuitive but solid consequence ensues: a more expensive model that reduces revision may cost less in total. And that's exactly what OpenAI claims at different points in the ad, declaring costs per task lower despite the higher rate.

These are manufacturer estimates on individual benchmarks, not independent measurements. But they indicate where to look: the cost per task completed, not the price per token.

A complete case, from quote to invoice

Let's follow a realistic example, because it shows where estimates break.

The initial estimate. One company wants to analyze 8,000 documents per month. Table calculation: 2,500 tokens per document, 600 response. Result: $200 input plus 240 output, $440 a month. Seems sustainable.

What happens in production. The system prompt, with the instructions and three examples, occupies 2,200 tokens and is paid for at every call: it is 17.6 million monthly tokens, i.e. $176 that no one had predicted. The reasoning level set to average brings the average output to 1,400 tokens instead of 600, so the output entry goes from 240 to $560. 15% of documents require a second step.

API spending has more than doubled. But the striking fact is the last line: if 5% of documents require a twenty-minute check, it's over one hundred and thirty hours a month — which is worth much more than a thousand dollars.

Where to intervene. Caching the system prompt brings that entry from $176 to about $18. Lowering the reasoning level, if the task is extraction, brings the output back close to the estimate. But the intervention with the highest return remains to reduce that 5% of documents to be reviewed — and that is achieved by improving the instructions, not changing the model.

The account on a real volume

Let's take a system that processes 20,000 requests per month, with 3,000 input tokens and 800 outputs each, all below the 272K threshold.

Two readings. The first: the output weighs more than input even with prompt four times longer than the answers, because it costs five times as much. Asking for concise answers where the length is not needed is the fastest intervention ever.

The second: moving that load to Batch, if it's not urgent, it's worth $8,400 a year. It is more than you get from any prompt optimization, and requires a configuration line.

How much does it cost compared to alternatives

To give a reference, here are the price lists of other top models, all per million tokens and all verified on the official documentation of their respective suppliers.

Astra is on exactly the same spot as Fable 5.1: at the top of the market the price has stopped being a competitive lever, and the two main suppliers have aligned.

Compared with the same producer’s previous generation, however, the jump is clear: Astra costs twice and a half GPT-5.6 Sol in input and twice and a half in output. It is a difference that must be justified with a measurable gain on its own cases, not with the data sheet.

The extended comparison between the tip bands is in the leading models in price comparison.

A Note on the Comparison of Plans

When comparing Astra with a Google model, remember that the two price lists are not built in the same way: OpenAI displays a single tariff with declared modes (Standard, Batch, Flex, Fast), Google articulates the price on service plans and on some models applies scales for prompt size.

An honest comparison therefore requires declaring which mode is being quoted on both sides. Comparing an OpenAI Batch figure with a Google priority price, or vice versa, creates a difference that does not exist.

The way to neutralize all this is always the same: run a hundred real cases on both, read the tokens actually consumed and divide the total expense for the cases concluded correctly. That number is comparable; the list price alone is not.

From here, three useful insights. For full official numbers see GPT-6 Astra: what it is and what changes. The price list with the conditions that change the account is in GPT-6 Astra: all official benchmarks. And for the verdict by type of company, Where GPT-6 Astra is not the best.

The Question That Decides

All the numbers in the ad converge on one distinction: Does your task require performing or knowing?

On tasks that require you to complete work, the jump is tens of points. On those that require you to know, it is fractions of a point.

If your process is "answering questions about our documents", this model gives you little more than the previous one and costs two and a half times. If it is "complete, verify, update, bring to a conclusion", the picture changes.

When You Justify

The right column covers most of the AI projects that an SME faces first. For those there is, in the same OpenAI family, a model that costs a 50th Input.

The left column instead describes a space that until now was difficult to automate: processes that go through non-integrable software, where the alternative was to pay for a custom integration or continue by hand.

The Cost Paradox

There is a counterintuitive point that deserves attention before discarding it for price.

Astra costs more per token, but OpenAI declares costs per task lower on several benchmarks: about 63% less than Fable 5.1 on Terminal-Bench 4.0, about 43% less than Sol on BenchCAD, about 65% less output tokens than Opus 5 on Agents' Last Exam.

The mechanism is simple: if the model consumes fewer steps and fewer tokens to get to the result, the higher rate is compensated. And if it increases the percentage of tasks completed without human intervention, it reduces the greatest voice of all — people's time.

They are manufacturer estimates, not independent measurements. But they indicate what to measure: not the price per token but the cost per task completed, by the method described in how much does GPT-6 Astra really cost.

What matters more than the model

It is worth being clear about one thing: the choice of model is rarely the factor that decides the success of an AI project in the company.

The papers. A system that responds from a messy document base will produce messy responses, with any model. Sorting those documents is worth more than any technical choice.

The instructions. Precise, not long. An ambiguously described field produces errors that look like model tantrums and are instead inaccurate instructions.

Integration. If the system requires you to open another tool or change habits, adoption collapses in a few weeks. It is the most frequent cause of failure, much more than the wrong model.

The controls. A weekly sample of outcomes reviewed by one person. Half an hour that protects the entire investment.

Three business profiles

Service SMEs, ten people, first AI project. Typical work is responding to recurring requests and producing standard documents. Neither requires this band: they resolve with models that cost a fifth or less. The advice is to start there, measure, and if anything go up after understanding the problem —not before.

Manufacturing company with legacy business management software. Here the picture changes. If there are processes that go from a software without API — placing orders, updating records, controls on external portals — the use of the computer opens a possibility that was not there before. It is worth the test on ten complete streams.

Professional study with complex document analysis. Few practices per month, each of high value and with an important error cost. The unit price matters little; it matters that the model signals the doubtful points instead of solving them silently. It is a case where the high end justifies itself, but where it is also better to compare the alternatives at the same price.

The general criterion for an SME, independent of the specific model, is in which AI model suits an SME.

The constraint that excludes upstream

Three technical limits can close the evaluation before you start, and it is worth checking them first.

Audio and video not supported. If the process involves transcription of calls or analysis of spoken content, another instrument is needed side by side — and at that point it is best to rethink the entire architecture.

Fine-tuning unavailable. You cannot specialize the model on the language of your company. The equivalent result is obtained with instructions and reference documents, but it is a different choice that needs to be designed.

Controls can stop a task. In API the execution is interrupted. For an unsupervised night stream it is an architectural requirement: you need to record the interruption and bring it to someone's attention.

None of the three are insurmountable, but discovering them mid-project costs much more than verifying them on the first day.

To go deeper. If you are considering adoption, start from GPT-6 Astra: what it is and what changes. The calculation of real expenditure —the one that includes reasoning, attempts and human review —is in GPT-6 Astra: prices and how to pay, while the stated limits are collected in GPT-6 Astra: all official benchmarks.

The first project, if you decide to leave

A final recommendation that applies regardless of the model chosen.

The first AI project of a company should not be the most ambitious: it should be the one that allows learning without risk. A repetitive process, with clear criteria, sufficient volumes to justify automation and recognizable and correctable errors.

An ambitious first project is likely to disappoint, and an initial disappointment closes the door on everything else for years. A simple project that works well instead creates the trust and experience to deal with a more difficult one — and produces, as a side effect, the data needed to calibrate everything else.

If the use case that justifies Astra is complex —an agent that operates within software, a chain of many steps —it is worth double: it is better to get there by degrees, starting from a piece of the process instead of everything together.

The questions to ask to those who propose it

If a provider or consultant proposes this model to you, three questions reveal in a few minutes how much work is behind it.

• "Have you tried a lower band? With what result?"
• "What happens when the model can't answer?"
• "How much human review is left after automation?"

The first is the one that saves the most: the commercial temptation pushes up, and those who propose a lower band explaining why enough is working in your interest.

The second separates a serious proposal from a demo. If there is no precise answer, the system will safely close even cases that it has not understood — and those produce errors that no one will verify.

The third is the one that establishes the real return. An automation that leaves 30% of cases to be reviewed by hand has freed up much less time than it seems.

How to present the cost to those who decide

A practical point that is often lacking. The cost of an AI project is difficult to communicate because the natural comparison — "it used to cost X, now Y" — often does not exist: that work before was not done, or was done by people whose time was not tracked.

Three ways that work better than direct comparison.

• Cost per case treated: a small and comparable figure over time
• Free hours: how many hours of repetitive work are back available
• Things you do now and before they were left behind

The third is almost always the most convincing, because it describes a gain that the cost comparison does not capture: an archive finally classified, a check done on everything instead of sample, an answer that comes in minutes instead of days.

From here, three useful insights. For full official numbers see GPT-6 Astra: what it is and what changes. The price list with the conditions that change the account is in GPT-6 Astra: prices and how to pay. And for the verdict by type of company, GPT-6 Astra: all official benchmarks.

Practical examples

Data extraction, 20,000 documents per month. 1,500 Token System Prompt, 2,000 Document, 400 Response, Low Reasoning Level. Order of magnitude: about $300 base, which drops sensibly with the cache on the prompt and with Batch if the load is night.

Internal assistant, 3,000 requests a month. Low volumes: API spending is in the order of a few tens of euros and is not the item to optimize. It is advisable to invest time in the quality of the documents provided.

Officer on multi-step duties, 5,000 executions a month. Here the cost grows more than linearly, because with each step the context lengthens and failed attempts are paid for whole. The estimate should be made on complete executions, not on single calls.

Mistakes to Avoid

• Multiplying to Table instead of measuring the real tokens.
• Forgetting the system prompt, that you always pay.
• Estimating output from length of visible answers.
• Ignoring the 272K threshold.
• Excluding People's Time from the calculation.
• Treating bulk cargoes as urgent.

The third point deserves clarification: on the models that reason, the intermediate tokens do not appear in the final text but you pay. Estimating consumption by the length of the response systematically leads to underestimating it.

How to apply it in the company

The procedure that produces a reliable estimate takes an afternoon and replaces any theoretical calculation.

Take one hundred real cases and run them on the model. Read the actual consumed tokens, which the API reports for each call — it's the only way to capture system prompt, reasoning, and verbosity at once. Add up everything, including failed attempts, and divide by the number of cases concluded correctly.

Then add the review time: minutes per case multiplied by the monthly volume.

The order of interventions that saves the most, in order of return:

• Check if this band is needed — worth up to 95%
• Move non-urgent loads on Batch or Flex — is worth 50%
• Cache the stable context — worth up to 90% on that portion
• Lower the reasoning where not needed — it's worth a lot on the output
• Shorten System Prompt — one hour's work, permanent effect

The first point comes first: to classify or extract there is almost always a band that does the same work at one fiftieth, according to the criterion of when an economic model is enough.

Conclusion

The price of a model is not its price list. It's the price list multiplied by how you use it: how many times you send back the same system prompt, how much reasoning you ask, if you pass the 272,000 token threshold, how much human labor stays downstream.

Before you decide, count on a real volume for a month and compare it with the cheaper alternative that still brings home the result. If the difference is not seen in the budget, the choice is already made. To understand what the model does, start from What it is and where it doesn't get; for numbers, the Official Benchmarks.