# GPT-6 Astra API Pricing: Rates, Caching, and Cost Examples

> GPT-6 Astra starts at $10 per million ordinary input tokens and $50 per million output tokens. Calculate request costs with the correct cache categories, context band, and processing tier.

- URL: https://blog.laozhang.ai/en/posts/gpt-6-astra-api-pricing
- Published: 2026-09-04
- Updated: 2026-09-07
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: API Pricing & Plans
- Tags: GPT-6 Astra, OpenAI API, API pricing, long context

---
GPT-6 Astra costs **$10 per million ordinary input tokens and $50 per million output tokens** on OpenAI's direct API for Standard processing with 272,000 input tokens or fewer. In the same band, cached input costs $1 per million and cache writes cost $12.50 per million. Requests above 272,000 input tokens use higher rates for the entire request, including output. These are OpenAI's [current API list prices](https://developers.openai.com/api/docs/pricing), checked on **September 7, 2026**.

To estimate a bill, first select the price band from each request's total input. Then split that input into ordinary input, cache reads, and cache writes, and add the output charge. A request with 120,000 total input tokens can cost $0.78 in the worked example below; charging all 120,000 at the ordinary rate and adding cache charges would overstate it.

All figures below are in USD for the direct OpenAI API. They exclude taxes and negotiated terms; ChatGPT subscriptions and third-party provider bills use separate pricing.

## The price card has two context bands

OpenAI publishes four token rates because ordinary input, cache hits, cache creation, and generated output do not cost the same. The Standard rates are:

| Billed token category | 272,000 input tokens or fewer | More than 272,000 input tokens |
| --- | ---: | ---: |
| Ordinary input, excluding cache reads and writes | $10.00 | $20.00 |
| Cached input | $1.00 | $2.00 |
| Cache writes | $12.50 | $25.00 |
| Output | $50.00 | $75.00 |

All prices are per 1 million tokens. The [GPT-6 Astra model page](https://developers.openai.com/api/docs/models/gpt-6-astra) states that more than 272K input tokens doubles the input and cache rates and raises the output rate by 50% **for the full request**. Cached input and cache writes still count toward the input total used to select that band.

The threshold is a price boundary, not the model's maximum capacity. The same model page explicitly lists a 1,050,000-token context window, a **922,000-token maximum input**, and up to 128,000 output tokens. A request can fit within those limits and still use the higher prices.

## Calculate a request from its usage fields

OpenAI's [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching#monitor-cache-performance) calculates ordinary input by subtracting both cache categories from total input. Cache reads and cache writes are subsets of `input_tokens`, not extra tokens to add to it:

```text
ordinary input = input_tokens
                 - input_tokens_details.cached_tokens
                 - input_tokens_details.cache_write_tokens
```

For example, suppose a response reports the following usage. This is an illustrative usage object, not a captured API response:

```json
{
  "input_tokens": 120000,
  "input_tokens_details": {
    "cached_tokens": 80000,
    "cache_write_tokens": 20000
  },
  "output_tokens": 5000
}
```

The total input is 120,000 tokens, so Standard short-context prices apply. Ordinary input is 120,000 − 80,000 − 20,000 = 20,000 tokens. Assign each input token to exactly one category:

| Component | Calculation | Cost |
| --- | ---: | ---: |
| Ordinary input | 20,000 / 1,000,000 × $10 | $0.20 |
| Cached input | 80,000 / 1,000,000 × $1 | $0.08 |
| Cache writes | 20,000 / 1,000,000 × $12.50 | $0.25 |
| Output | 5,000 / 1,000,000 × $50 | $0.25 |
| **Token subtotal** | | **$0.78** |

The $12.50-per-million cache-write rate is the complete rate for those tokens. It is not a surcharge to add after charging them at the $10-per-million ordinary-input rate. If your logs produce a negative ordinary-input count, check the recorded fields and aggregation before estimating a cost.

![An illustrative Astra request splits 120,000 input tokens into ordinary input, cached input, and cache writes, then adds output for a $0.78 token subtotal.](https://blog.laozhang.ai/posts/en/gpt-6-astra-api-pricing/img/usage-cost-breakdown.webp)

Use the full `output_tokens` value for output billing. OpenAI's [reasoning guide](https://developers.openai.com/api/docs/guides/reasoning#controlling-costs) explains that reasoning tokens are billed as output and included in that total. Do not add `output_tokens_details.reasoning_tokens` a second time, or estimate the bill from visible answer length alone. `max_output_tokens` limits total generated tokens, including reasoning, visible output, and non-visible formatting tokens.

Calculate each request before adding up a workload. Daily input totals cannot determine whether an individual request crossed 272K. Aggregation is safe only after separating requests with the same model rates, input band, and processing tier.

## When a cache write pays for itself

Cache writes cost 1.25 times the ordinary-input rate, while successful reads cost 0.1 times that rate. OpenAI's [caching guide](https://developers.openai.com/api/docs/guides/prompt-caching#how-caching-works) therefore makes reuse the key to recovering the initial write premium.

Consider a **100,000-token prefix** written once and fully reused once, with both requests staying at or below 272,000 total input tokens under Standard processing:

```text
first use, cache write: 100,000 / 1,000,000 × $12.50 = $1.25
second use, cache read: 100,000 / 1,000,000 × $1.00  = $0.10
combined prefix cost:                                $1.35

two ordinary-input uses: 2 × 100,000 / 1,000,000 × $10 = $2.00
```

The input-only saving is $0.65 across those two uses. This comparison excludes changing suffixes, output, and tools. It assumes the first request writes the prefix and the second actually records a full cache hit; it is rate-card arithmetic, not measured invoice savings.

Stable text alone does not guarantee that result. The rendered prefix must match an available cache entry at an eligible breakpoint, which marks the end of a cacheable prefix. If the first request only caches through a changing suffix, a later request with the same introduction may still miss. An explicit breakpoint after reusable material can make that prefix available for reuse. In explicit-only mode, placing no breakpoints means no cache writes. See the [caching guide's shared-prefix example](https://developers.openai.com/api/docs/guides/prompt-caching#gotchas) before assuming that repeated text will receive the cached rate.

For Astra, `prompt_cache_options.ttl` currently supports `"30m"`, which is also the default. Reuse refreshes the cache lifetime. Budget from recorded `cached_tokens` and `cache_write_tokens` rather than treating the retention setting as a guaranteed hit rate. The [cache lifetime documentation](https://developers.openai.com/api/docs/guides/prompt-caching#cache-lifetime) explains the current behavior.

## Crossing 272K reprices every token in the request

Consider a Standard request with 300,000 ordinary input tokens, no cache activity, and 20,000 output tokens. The request exceeds the threshold, so every input token uses the $20 long-context rate and every output token uses the $75 rate:

```text
input:  300,000 / 1,000,000 × $20 = $6.00
output:  20,000 / 1,000,000 × $75 = $1.50
total:                                      $7.50
```

The discontinuity matters even when only one input token crosses the line. With no cache activity and the same 20,000-token output:

| Input tokens | Standard input cost | Standard output cost | Total token cost |
| ---: | ---: | ---: | ---: |
| 271,999 | $2.71999 | $1.00 | $3.71999 |
| 272,000 | $2.72 | $1.00 | $3.72 |
| 272,001 | $5.44002 | $1.50 | $6.94002 |

These are unrounded calculations from the published rates. Exactly 272,000 remains in the lower band. The next input token changes the price of the entire request; only repricing the excess token would substantially understate the cost.

![A comparison of Standard request costs at 272,000 and 272,001 input tokens, showing that crossing the threshold reprices both input and output.](https://blog.laozhang.ai/posts/en/gpt-6-astra-api-pricing/img/context-threshold-cost.webp)

This does not mean you should always trim a prompt below 272K. Retrieval, summarization, or splitting a task can remove context that the model needs and can create extra requests. Measure tasks below and above the threshold separately, then compare both quality and total cost.

## Processing mode, region, and tools change the subtotal

After selecting the correct context band, apply the processing mode. OpenAI's [direct API price table](https://developers.openai.com/api/docs/pricing) makes Batch and Flex half of Standard, while Fast is twice Standard:

| Processing mode | Relative token rate | Cost for the $0.78 example |
| --- | ---: | ---: |
| Batch | 0.5× Standard | $0.39 |
| Flex | 0.5× Standard | $0.39 |
| Standard | 1× | $0.78 |
| Fast | 2× Standard | $1.56 |

Choose one mode. Batch and Flex discounts do not stack, and a price copied from a mode-specific rate table already includes that mode's adjustment.

The table compares token prices, not delivery guarantees. For Fast, the request accepts `service_tier: "fast"` or `service_tier: "priority"`. Record the **returned** `service_tier` when reconciling usage: some traffic can fall back to `default` and receive Standard pricing. Astra Fast has no latency SLA and is unavailable with EU data residency. These conditions are documented in the [Fast mode guide](https://developers.openai.com/api/docs/guides/fast-mode).

The [pricing terms](https://developers.openai.com/api/docs/pricing) apply a 10% uplift to eligible regional-processing endpoints for qualifying models released on or after March 5, 2026. Confirm that it applies to your configuration before multiplying the applicable token subtotal by 1.10. The $0.78 Standard example would become $0.858 before tools and tax.

Tools are additional. The [API pricing page](https://developers.openai.com/api/docs/pricing#built-in-tools) lists web search at $10 per 1,000 calls, or $0.01 per call, plus search-content tokens billed at model rates. Three search calls add $0.03 in call fees. Include the search-content tokens once in the token calculation; do not add them again if your recorded input usage already includes them. File-search calls and storage, and hosted containers, have their own charges. The Responses and Chat Completions endpoints do not carry a separate access fee.

A practical estimate is:

```text
API cost = sum of each request's token cost
           at its context band and processing tier,
           including any applicable regional uplift
           + separately billed tool calls, storage, and container usage
```

Do not apply token-price multipliers to flat tool-call fees. Keep taxes, contractual discounts, and provider-specific billing separate until you have the applicable terms. If you use Astra through Amazon Bedrock, AWS owns the bill; OpenAI's direct-API rates do not establish the AWS price.

## Decide with cost per accepted task, not cost per attempt

Astra's [current direct-API token rates](https://developers.openai.com/api/docs/pricing) are 2.5 times GPT-5.6 Sol's when the token mix, context band, and processing mode are identical. For the $0.78 example, the same mix would cost $0.312 on Sol. Sol's current promotional pricing is available at least through November 21, 2026; recheck the rate card for a longer-term forecast.

That comparison says nothing by itself about which model completes your work more reliably. Compare the cost of tasks that meet your requirements:

```text
cost per accepted task =
  (API spend for successful and failed attempts
   + human review and repair cost
   + other workflow cost)
  / accepted tasks
```

If both models use the same number and mix of tokens per attempt, Astra must complete the same amount of accepted work with 40% as many billable attempts as Sol to reach token-cost parity. Alternatively, it must save enough review, repair, or other workflow cost to recover its higher API spend. Actual token use may also differ, especially when reasoning and tool calls are involved.

Run a bounded pilot on representative tasks:

1. Define acceptance before running either model, using a test, rubric, or human decision that matches production.
2. Record the model ID, returned processing tier, input band, reasoning effort, tool use, and the four billed token categories for every attempt.
3. Track rejected outputs, retries, review time, repair time, and manual steps eliminated.
4. Compare total cost per accepted task, separating requests above 272K from shorter requests.

Pilot Astra where rejects or manual repair are expensive and you can score the result. Keep a cheaper model for work it already completes reliably. Use Batch or Flex when their operating behavior fits the job; pay for Fast when lower delay justifies the premium without assuming an SLA.

Before running the pilot, confirm access in the project that will pay for it. The [GPT-6 Astra API access guide](https://blog.laozhang.ai/en/posts/gpt-6-astra-api-access) covers that check and the first request. Once access works, use recorded usage and accepted results to decide whether Astra's results justify its higher price.

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-09-07.

- [current API list prices](https://developers.openai.com/api/docs/pricing) (developers.openai.com)
- [GPT-6 Astra model page](https://developers.openai.com/api/docs/models/gpt-6-astra) (developers.openai.com)
- [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching) (developers.openai.com)
- [reasoning guide](https://developers.openai.com/api/docs/guides/reasoning) (developers.openai.com)
- [Fast mode guide](https://developers.openai.com/api/docs/guides/fast-mode) (developers.openai.com)