GPT-6.1 Terra 12h Cache: $0.74 vs $1.06 a Day

OpenAI released GPT-6.1 Terra on 26 October 2026. It costs $1 per million input tokens and $5 per million output, exactly half of GPT-6.1 Sol on every line of the pricing table. It also gets Sol's cheaper cache reads: $0.05 per million, 5% of the input rate, where most GPT-6 models pay 10%.

Six days earlier OpenAI added a 12-hour prompt cache to the Responses API. The write costs 2.5x the input rate instead of 1.25x for the default 30 minutes. For a bot whose traffic arrives in bursts through the day, that choice moves the bill more than the model does. I costed one realistic workload four ways from the official rates.

Table of contents

• What shipped
• How a cached request is billed
• The workload
• Four ways to cache the same day
• When 12 hours beats 30 minutes
• The request that gets it right
• Terra against Sol and Luna
• FAQ
• Sources

What shipped

Batch and Flex are 50% off Standard, and Fast mode costs 2x. Regional processing adds 10%. Above 272K input tokens the whole request bills at 2x input and cache rates and 1.5x output, the same rule as the rest of GPT-6. Tool calling needs the Responses API; Chat Completions works for plain text.

How a cached request is billed

On GPT-5.6 and later, every input token lands in exactly one of four buckets. A write is the full price for that token, not a fee on top of normal input.

The usage object tells you which bucket each token fell into: cached_tokens for reads, and cache_write_tokens_details split into ttl_30m_tokens and ttl_12h_tokens. Whatever is left of input_tokens is ordinary input. Reads cost the same whichever lifetime wrote them.

A 30-minute read refreshes its entry for another 30 minutes. It does not restart a 12-hour clock, and it never triggers a second write.

The workload

A support assistant for one product, running on Terra:

• A 40,000-token prefix: system instructions, tool definitions and a product manual. It changes once a day at most.
• A 2,000-token tail per request: the customer's question and a little account context.
• 800 output tokens per answer.
• Traffic comes in 8 bursts a day of 10 requests each, 80 requests total. The gap between bursts is longer than 30 minutes, so a 30-minute entry has expired by the next one.

That last point decides the result. It describes most internal tools and small-business bots, where usage follows meetings and shifts, not a steady stream.

Four ways to cache the same day

Output is identical in every case: 80 × 800 tokens at $5 per million is $0.32 a day. Only input changes.

The default setting already cuts the uncached bill by about 71%. The explicit 12-hour breakpoint saves another $0.326 a day on top of that, 30.6% less than the default. Here's where it comes from:

• The 30-minute cache rewrites the 40K prefix at the start of all 8 bursts. That's 8 × $0.05 = $0.40 a day in writes. The 12-hour cache writes it once for $0.10.
• Implicit mode puts its breakpoint at the end of the latest user message, so each customer's question gets written to cache too. Nobody asks the same question twice, so those writes are waste. At 30 minutes a tail write is $0.0025 against $0.002 uncached. At 12 hours it's $0.005, which is why implicit 12-hour only saves $0.086 a day over the default.

For the implicit rows I've assumed each new request reads the 40K prefix back through the end of the developer block, one of the lookup boundaries the guide lists for implicit mode. If your prompt layout breaks that match, implicit caching does worse than the table shows.

You can redo this with your own token counts in the API cost calculator. Use it for the output side and the headline rates, then add the write lines by hand, since the calculator has no cache-write field.

When 12 hours beats 30 minutes

Compare only the prefix. A 30-minute write costs 1.25x the input rate each time the cache goes cold. A 12-hour write costs 2.5x once.

• 1 cold start a day: 30 minutes wins (1.25x against 2.5x).
• 2 cold starts: a tie at 2.5x.
• 3 or more: 12 hours wins, and the gap grows by 1.25x for every extra one.

A steady stream of requests never lets the 30-minute entry expire, because each read refreshes it. In that case the 12-hour option costs more and buys nothing. It pays when your traffic has gaps longer than half an hour, three or more times a day.

OpenAI's guide adds one caveat. The lifetime is a minimum for read pricing. It doesn't guarantee that a request lands on the machine holding the cache, and traffic above about 15 requests per minute on one prefix can spill to other machines.

The request that gets it right

Use explicit mode, put a 12-hour breakpoint on the stable prefix, and leave the question after the last breakpoint so it bills as plain input with no write. Based on the example in OpenAI's prompt caching guide:

{
  "model": "gpt-6.1-terra",
  "prompt_cache_options": { "mode": "explicit", "ttl": "30m" },
  "input": [
    {
      "role": "developer",
      "content": [
        {
          "type": "input_text",
          "text": "YOUR_INSTRUCTIONS_AND_PRODUCT_MANUAL",
          "prompt_cache_breakpoint": { "mode": "explicit", "ttl": "12h" }
        }
      ]
    },
    {
      "role": "user",
      "content": [
        { "type": "input_text", "text": "YOUR_CUSTOMER_QUESTION" }
      ]
    }
  ]
}

A few rules from the guide that trip people up:

• Top-level instructions can't hold a breakpoint. Put the reusable text in an input_text block inside a developer message, as above.
• In explicit mode with no breakpoints, nothing is cached at all.
• Each request can create up to four cache writes, and the prefix has to be at least 1,024 visible tokens.
• ttl only works in the Responses API. Chat Completions stays on the 30-minute default.
• Changing anything before the breakpoint, even a tool schema, means a fresh write. Put the date or user name after it.

To check it worked, watch ttl_12h_tokens in the usage object. It should show 40,000 on the first request of the day and zero after that, while cached_tokens sits at 40,000.

Terra against Sol and Luna

Every Terra rate is exactly half of Sol, so the same day costs half too. Luna is a tenth of Terra.

Luna figures are rounded from $0.1208 and $0.0896. Luna's read rate is 10% of input, so its cached prefix costs relatively more, but at $0.10 input it's still far cheaper. The question is quality. OpenAI positions Luna for high-volume simple tasks and Terra for images, screen work and writing. A support bot that reads screenshots or drafts long replies is the case for Terra. A bot that classifies tickets is the case for Luna.

FAQ

Does the 12-hour cache delete my data after 12 hours? No. The guide says "12h" is a minimum for read pricing, not a deletion deadline, and it doesn't change OpenAI's data-retention policy.

Is Terra cheaper than GPT-5.6 Terra? On input, yes: $1 against $2. Output is $5 against $12. GPT-5.6 Terra's cached input is $0.20, four times the new model's $0.05.

Can I use the 12-hour cache with Batch? Batch is 50% off Standard rates. The model page doesn't say how cache writes combine with Batch, so test with a small job before relying on it.

Sources

• OpenAI, GPT-6.1 Terra model page (developers.openai.com/api/docs/models/gpt-6.1-terra, read 27 October 2026): rates, cache-write prices for both lifetimes, context, max output, knowledge cutoff, modalities, long-context rule, Batch/Flex/Fast/regional pricing.
• OpenAI, API pricing (developers.openai.com/api/docs/pricing, read 27 October 2026): flagship table for GPT-6 Astra, GPT-6.1 Sol, GPT-6.1 Terra and GPT-6 Luna.
• OpenAI, API changelog (developers.openai.com/api/docs/changelog, read 27 October 2026): Terra release on 26 October, 12-hour prompt caching on 20 October.
• OpenAI, Prompt caching guide (developers.openai.com/api/docs/guides/prompt-caching, read 27 October 2026): write multipliers, read rates for Sol and Terra, explicit and implicit breakpoints, ttl, usage fields, the request example.
• ToolMintX API Cost Calculator data (GPT-5.6 Terra rates). Daily costs are calculated by ToolMintX from the rates above.