{"slug": "gpt-6-2-api-migration-caching-traps-and-8-hour-windows", "title": "GPT-6.2 API Migration: Caching Traps and 8-Hour Windows", "summary": "OpenAI's November 17 release of GPT-6.2 Astra and Sol changes how prompt caching and background completions bill, and migrations that pass a single text-only smoke test can still pay full input rates on repeated instructions, according to an account of the API changelog and migration quickstart. Top-level `instructions` are now placed after `input` and billed as uncached input on every request, even when their text repeats, and editing an old message or tool result can invalidate later reasoning items. The two-hour and eight-hour public-beta background windows cost 30% and 40% less than Standard model token rates, and GPT-6.2 tool calling requires the Responses API rather than Chat Completions.", "body_md": "After switching a working application to GPT-6.2, the first request is a poor migration test. It can succeed even when a repeated set of instructions will be billed at the ordinary input rate forever. The second request reveals another problem: an application that tidies an old tool result before sending it back can cause the model to lose reasoning that followed it.\n\nOpenAI introduced these changes with GPT-6.2 Astra and Sol on November 17. It also added discounted two-hour and eight-hour background completion windows. They make a difference to a workflow that can wait and needs to choose its next step from a result. A cheaper option already exists for independent requests known in advance. The migration is easier to evaluate if you test prompt reuse, conversation continuity and scheduling separately. [OpenAI’s API changelog](https://developers.openai.com/api/docs/changelog)\n\n1. 01Move reusable policy to the front.A leading developer message in input can be cached. Top-level instructions now apply to the current request after input and are billed uncached even when their text repeats.\n2. 02Preserve the original history.Editing an old message or tool result can invalidate later reasoning items. Check cache diagnostics and input_transformations separately when the second turn gets more expensive.\n3. 03Use asynchronous discounts where work can wait.The two-hour and eight-hour public-beta windows cost 30% and 40% less than Standard model token rates. The time target covers the initial response.\n4. 04Keep storage and scheduling separate.The API can temporarily retain encrypted application state for discounted requests, including on approved Zero Data Retention projects. Batch has different eligibility and file rules.\n\n## 01 — CompatibilityStart with a request that *works*\n\nSet the direct identifier to `gpt-6.2-astra` or `gpt-6.2-sol`. For an application that calls tools, use the Responses API. Chat Completions can serve a text-generation path, but GPT-6.2 tool calling requires Responses. A successful text-only smoke test does not exercise a function call, the matching tool output or the model’s subsequent turn. Keep a representative tool interaction in your migration test. [OpenAI’s migration quickstart](https://developers.openai.com/api/docs/guides/latest-model#migration-quickstart)\n\nOpenAI suggests medium reasoning effort for a new integration. Replace an older `none` or `minimal` setting with `low`. The fields differ by endpoint: `reasoning.effort` in Responses and `reasoning_effort` in Chat Completions. Remove `temperature`, `top_p` and `top_logprobs` from both paths. Chat Completions should also omit `logprobs`. In Responses, remove `message.output_text.logprobs` from `include`.\n\nTest the payload your application actually sends. A shared SDK wrapper can put sampling defaults back into a request after your application code removes them. Also check the downstream reader of the answer. GPT-6.2 tends to write more concisely by default. If your application relies on a human-readable explanation beside a structured result, specify what the explanation must contain and check an example in the destination screen.\n\n## 02 — Prompt layoutPrice the *prefix*\n\nIn Responses, GPT-6.2 places top-level `instructions` after `input`, beyond the cacheable boundaries. OpenAI bills those instruction tokens as ordinary input each time, even on a request that otherwise gets a cache hit. They also do not carry over via `previous_response_id`. That makes the field convenient for guidance that applies only now. Put the durable policy and reference material in the first developer message instead. [OpenAI’s prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching)\n\nConsider a support triage application with a long, stable policy and a different ticket each time. In the migrated request below, the reusable policy comes first, the ticket follows, and the top-level guidance requests a one-off output style. The two strings named in uppercase are application variables. A prefix needs at least 1,024 visible input tokens to become cacheable. Short examples like this show placement and do not guarantee a hit.\n\n``` js\nconst result = await client.responses.create({\n  model: \"gpt-6.2-sol\",\n  reasoning: { effort: \"medium\" },\n  prompt_cache_options: { mode: \"implicit\", ttl: \"30m\" },\n  input: [\n    { role: \"developer\", content: TRIAGE_POLICY },\n    { role: \"user\", content: TICKET_TEXT },\n  ],\n  instructions: \"Write the summary in the recipient’s language.\",\n});\n```\n\nWith implicit caching, the API chooses an eligible breakpoint. Candidates include the last developer message in the initial developer group, user messages and the last tool response in a consecutive group. Explicit mode lets you select reusable boundaries by marking supported content blocks with `prompt_cache_breakpoint`. With explicit mode and zero marked blocks, the request neither reads nor writes the prompt cache. With implicit mode you may add explicit boundaries alongside the automatically selected one. Up to four writes are available per request, including the implicit one if used.\n\n## 03 — Token billCount the write *once*\n\nOn Sol’s standard short-context rates, a million ordinary input tokens cost $2, cached reads $0.10, 30-minute writes $2.50 and 12-hour writes $5. On Astra, the same categories cost $8, $0.40, $10 and $20. A cache write replaces the ordinary input charge for those tokens. The bill goes wrong if an estimator charges the same tokens once as input and again as cache writes. [Sol model pricing](https://developers.openai.com/api/docs/models/gpt-6.2-sol) · [Astra model pricing](https://developers.openai.com/api/docs/models/gpt-6.2-astra)\n\nFor a simple example, suppose a 10,000-token policy is used by ten standard short-context Sol requests. As ten uncached inputs that policy costs $0.20. One 30-minute write costs $0.025 and nine full reads cost $0.009 in total, bringing the policy to $0.034. That assumes all nine lookups hit within coverage. Tickets, outputs, other tools and any additional writes are outside this illustration. If every ticket carries a different timestamp ahead of the policy, the underlying prefix has changed and that arithmetic no longer describes the workload.\n\nWhen migrating from GPT-5.5 or earlier, replace `prompt_cache_retention` with `prompt_cache_options.ttl` and start with `30m`. In Responses, `12h` offers longer minimum coverage at the higher write rate. A lifetime is a minimum for pricing coverage, not a deletion deadline or a latency guarantee. Inspect `usage.input_tokens_details` for reads, writes and their lifetime breakdown. For requests above 272,000 input tokens, both models double input and cache rates and charge 1.5 times the output rate for the full request.\n\n## 04 — Conversation stateAppend the *correction*\n\nA prefix change can have two costs. It can stop matching cached input after the first difference. It can also cause the API to discard reasoning items that follow the edit. Certain model changes, including downgrades, and changes to the end user or organisation can also drop reasoning items. An apparently tidy second turn may therefore consume extra tokens rebuilding earlier work, or return a weaker answer. [OpenAI’s guide to preserving the prefix](https://developers.openai.com/api/docs/guides/keep-prefix-unchanged)\n\nSuppose a tool returns the last 100 lines from a ticket history. On the next turn the application replaces that result with a five-line summary to save space. The earlier reasoning now follows a different input. Instead, trim the original tool output before the model sees it for the first time, or append the summary as new context. When native compaction is appropriate, follow OpenAI’s instructions for replaying its returned window in order. Native compaction can preserve subsequent reasoning even when the changed prefix costs a cache hit.\n\nUse two distinct observations in the rollout. Compare selected requests with Prompt Cache Diagnostics to find why a prefix missed. A hit count cannot prove reasoning survived. The Responses API’s `input_transformations` reports removed reasoning items and the reason. Compare that with a case where the application replays the original input and responses in order. That is a more informative test than assuming every token increase means the cache is broken.\n\n## 05 — SchedulingWhat the *two clocks* measure\n\nAstra and Sol do not support `service_tier: flex`. For deferred work, the Responses API offers public-beta discounted windows on GPT-6.2 Astra, GPT-6.2 Sol, GPT-6.1 Terra and GPT-6 Luna. Set `background: true`, `service_tier: \"default\"`, and `background_options.completion_window` to `2h` or `8h`. Omit `stream` or set it to false. With an automatic tier selection, the request qualifies only if the API chooses Standard. [OpenAI’s background mode guide](https://developers.openai.com/api/docs/guides/background)\n\nThe first clock starts when the API accepts the initial request. It targets an initial response within the chosen window. For an agent that requests a document lookup, that response might be a tool call. The application must then run the lookup and submit a follow-up. The time taken by the full workflow is a separate measurement. A two-hour window on the initial response is a poor promise to make to a customer who needs a fully reviewed report exactly two hours from now.\n\nFor a single call, save the returned response ID. For a multistep run, generate a unique `background_options.continuation_id` and reuse it with the same project, model, background setting, tier and window. That makes related requests eligible for higher queue priority. It does not carry conversation history. Use `previous_response_id` while the response is available and submit the tool output with its original call ID. If the response expires, replay the saved original input and all output items in order, including encrypted reasoning and the function call, then append the tool result. [Responses create reference](https://developers.openai.com/api/reference/resources/responses/methods/create)\n\n## 06 — Cost comparisonChoose by what is known *up front*\n\nThe two-hour window is 30% below Standard and the eight-hour window is 40% below Standard on eligible model token charges, including eligible follow-ups. The default background window, `soonest`, carries no model-token discount. The Batch API offers 50% off with a 24-hour window on independent requests the application can prepare in advance. Tool fees and external service charges are separate from these percentages. [OpenAI’s Batch API guide](https://developers.openai.com/api/docs/guides/batch)\n\nAssume 100,000 ordinary input tokens and 10,000 billed output tokens on Sol at short-context rates, with no cache writes, reads or separately priced tools. The Standard model-token subtotal is $0.30. On identical usage it is $0.21 at two hours, $0.18 at eight hours and $0.15 in Batch. A list of prewritten ticket classifications can use Batch. A review that must fetch a different document depending on what the first response discovers can justify the extra three cents for the eight-hour route.\n\nDiscounted background and Batch requests share the model’s queued-input-token limit. Tokens count when submitted, so moving an overnight job off Batch may still leave it competing for the same queue allowance. Ordinary Standard traffic outside the discounted windows cannot reuse cache entries created by a two- or eight-hour background request. Check the cost of any final interactive turn separately, especially if it follows a long discounted review. [OpenAI’s shared rate-limit rules](https://developers.openai.com/api/docs/guides/rate-limits)\n\n## 07 — OperationsCollect the *result*\n\nAfter acceptance, OpenAI retries eligible capacity errors on two-hour and eight-hour requests. If the response is queued or in progress, wait for a webhook or poll the existing ID. A local HTTP timeout after submission is different from a terminal failure. Persist response IDs as soon as they arrive. Verify webhook signatures, deduplicate deliveries using the webhook ID and associate the event’s response ID with the saved job before applying a tool action. Handle failed, incomplete and cancelled events as well as completion.\n\nApproved Zero Data Retention projects can use the discounted windows. The API treats `store` as false, but still temporarily stores encrypted application state to process the request and make the response available for retrieval. OpenAI’s roughly ten-minute figure describes the default background window. Its data controls give no fixed post-completion retrieval duration for the discounted windows. Collect results promptly. The Batch endpoint is listed as ineligible for Zero Data Retention, a distinction that can decide between two otherwise suitable price points. [OpenAI’s retention rules by endpoint](https://developers.openai.com/api/docs/guides/your-data#v1responses)\n\nBefore changing the default, take one live-style exchange through two turns and one deferred exchange through a tool call and a redelivered completion event. Record billed input by category and the final answer your application accepted. The [prompt caching comparison](https://www.digitalapplied.com/blog/prompt-caching-changes-openai-anthropic-september-2026) explains the earlier billing changes, and the [Astra and Sol release guide](https://www.digitalapplied.com/blog/gpt-6-2-astra-sol-release-pricing-access) covers model selection. For a broader budget review use the [November API price tracker](https://www.digitalapplied.com/blog/ai-api-price-changes-retirements-november-2026). The same two test cases make a concrete brief for an [AI integration review](https://www.digitalapplied.com/services/ai-transformation).\n\n### Approve the migration on the second turn\n\nConfirm the response after a tool runs, the cost after a stable prefix is reused, and the time after the first background response arrives. Those observations tell you whether the migrated application can finish its work at the price and deadline you promised.", "url": "https://wpnews.pro/news/gpt-6-2-api-migration-caching-traps-and-8-hour-windows", "canonical_source": "https://www.digitalapplied.com/blog/gpt-6-2-api-migration-caching-background-windows", "published_at": "2026-11-19 00:00:00+00:00", "updated_at": "2026-11-19 09:46:21.946552+00:00", "lang": "en", "topics": ["large-language-models", "ai-products", "ai-tools", "developer-tools"], "entities": ["OpenAI", "GPT-6.2 Astra", "GPT-6.2 Sol", "Responses API", "Chat Completions"], "also_reported_by": [], "takeaway": "Move durable policy and reference material into the first developer message instead of top-level `instructions`, which GPT-6.2 places after `input` and bills as uncached input on every request, and test a representative tool interaction because GPT-6.2 tool calling requires the Responses API.", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/gpt-6-2-api-migration-caching-traps-and-8-hour-windows", "markdown": "https://wpnews.pro/news/gpt-6-2-api-migration-caching-traps-and-8-hour-windows.md", "text": "https://wpnews.pro/news/gpt-6-2-api-migration-caching-traps-and-8-hour-windows.txt", "jsonld": "https://wpnews.pro/news/gpt-6-2-api-migration-caching-traps-and-8-hour-windows.jsonld"}}