GPT-6.1 Terra Pricing Explained: API Costs, Cached Input, and Long-Context Fees

GPT-6.1 Terra pricing looks simple until an application adds long prompts, cached prefixes, image inputs, tools, or faster processing. The safest budget starts with the published text-token rates and then models each additional cost separately.

This guide uses OpenAI's prices as listed on October 27, 2026. Prices and availability can change, so production estimates should link to the live model and pricing pages rather than copying figures into a permanent contract.

Standard Text-Token Rates

For the gpt-6.1-terra API model, the current Standard rates per one million tokens are:

| Token category | Price per 1M tokens | | Uncached input | $1.00 | | Cached input | $0.05 | | 30-minute cache write | $1.25 | | 12-hour cache write | $2.50 | | Output | $5.00 |

Cached input is priced at 5% of the uncached input rate. A cache write costs more than ordinary input because OpenAI charges for retaining the reusable prefix for a minimum period. The economic benefit appears when subsequent requests reuse enough of that prefix.

Basic Cost Formula

For a Standard request without caching, long-context pricing, tools, or images:

cost = input tokens / 1,000,000 × $1 + output tokens / 1,000,000 × $5

Three examples:

1. 25,000 input and 2,000 output tokens: $0.025 + $0.010 = $0.035.
2. 100,000 input and 10,000 output tokens: $0.10 + $0.05 = $0.15.
3. 1,000,000 input and 100,000 output tokens: $1.00 + $0.50 = $1.50.

These are text-token estimates. An application that submits images, performs web searches, uses hosted execution, or operates a third-party browser environment can incur additional charges.

Long-Context Pricing Above 272K Input Tokens

Terra has a 1,050,000-token context window, but fitting a prompt into the context window does not mean every token is charged at the base rate. OpenAI's model page states that prompts exceeding 272,000 input tokens are charged at twice the input and cache rates and 1.5 times the output rate for the full request.

For a 300,000-token input and a 20,000-token output in Standard mode:

• Input: 0.3 × $2.00 = $0.60.
• Output: 0.02 × $7.50 = $0.15.
• Estimated total: $0.75 before other charges.

The multiplier applies to the complete request, not only the portion above 272,000 tokens. This makes context design important. Remove irrelevant material, retrieve only necessary files, or divide a job into verifiable stages when that preserves quality.

How Prompt Caching Changes the Calculation

Prompt caching is useful when many requests share a stable prefix, such as a long policy manual, product catalog, tool definitions, or consistent developer instructions. OpenAI's current caching controls offer minimum lifetimes of 30 minutes and 12 hours.

Consider a 200,000-token stable prefix reused ten times within the valid cache period, with no long-context multiplier:

• Initial 30-minute write: 0.2 × $1.25 = $0.25.
• Nine cached reads: 9 × 0.2 × $0.05 = $0.09.
• Total prefix cost: $0.34.

Sending the same 200,000 tokens uncached ten times would cost $2.00. This simplified example excludes the changing suffix and output, but it shows why stable prefixes matter.

Caching does not guarantee lower latency, does not change how output is generated, and does not remove cached tokens from tokens-per-minute limits. A changed prefix may also prevent the expected cache reuse.

Batch, Flex, Fast, and Regional Processing

OpenAI currently lists the following adjustments for Terra:

• Batch and Flex: 50% below Standard rates.
• Fast mode: twice Standard rates.
• Eligible regional processing: 10% above the applicable base rate.

These modes solve different constraints. Batch or Flex can fit work that tolerates delayed or variable completion. Fast can fit an interactive workflow where latency has measurable business value. Regional processing is a compliance and data-location choice rather than a performance upgrade.

Do not combine percentage statements casually. Confirm which mode, region, and long-context rules apply to the exact endpoint and request before publishing a budget.

Hidden Costs That Are Not Actually Hidden

Token tables do not capture the complete operating cost. Budget for:

• Image-input tokens and resolution choices.
• Web search or other tool charges.
• Computer-use screenshots and execution infrastructure.
• Hosted browser or desktop-provider fees.
• Retries caused by validation failures.
• Human review and exception handling.
• Storage, logging, observability, and security controls.

For computer use, the application supplies or connects an environment and executes permitted actions. That environment may have its own pricing. For image analysis, multiple images count toward the model input and context.

Estimate Cost Per Accepted Result

The most useful unit is not cost per request. It is cost per accepted result.

Suppose a visual-QA request costs $0.04 in API usage. If only 70% pass review on the first run and failed cases need another request plus five minutes of human work, the actual cost is much higher than $0.04. Another configuration may cost $0.06 per request but reach 95% first-pass acceptance.

Track these fields:

• Task type and difficulty.
• Model and reasoning effort.
• Input, cached, cache-write, and output tokens.
• Tool and environment fees.
• Latency and retry count.
• Reviewer time.
• Accepted, corrected, or rejected status.

Frequently Asked Questions

Is prompt caching always cheaper?

No. A cache write costs more than ordinary input. Savings depend on successful reuse of a sufficiently large stable prefix during the eligible period.

Does the 1.05M context window use standard pricing throughout?

No. The model accepts up to 1,050,000 context tokens, but requests above 272,000 input tokens receive long-context multipliers for the full request.

Does API pricing include ChatGPT Work or Codex access?

API billing and ChatGPT plan access are separate product contexts. Terra's availability in Work or Codex does not mean API usage is included, and API access does not automatically grant access in every ChatGPT surface.

Budgeting Recommendation

Start with a spreadsheet or cost log built from real usage data. Separate ordinary input, cache writes, cached reads, output, image tokens, tool calls, and environment fees. Then compare model configurations by accepted result. That approach is slower than multiplying one headline price, but it produces a budget a production team can actually use.