- OpenAI's new two-hour completion window takes 30% off for waiting. In my runs the wait was five minutes: 58 first requests on three models finished in 302 to 393 seconds, and 42 follow-ups that reused a
continuation_idfinished in 5 to 15. - The discounted window keeps its own prompt cache. A 7,426-token prefix that was warm on Standard was written again in full by the first 2h request, and a prefix written by a 2h request was cold on Standard.
- A
continuation_idtakes one request at a time and belongs to one window, the response never says which window it ran in, and withstore: falsethe result was gone ten minutes after it finished. I found all three by running into them.
On 17 November OpenAI added two discounted completion windows to background mode in the Responses API. Accept an answer within two hours and model tokens cost 30% less than Standard. Accept eight hours and it is 40%. They work on GPT-6.2 Astra and Sol, GPT-6.1 Terra and GPT-6 Luna.
The same changelog entry says new models will not get Flex processing. GPT-6.2 already has no Flex tier, so the windows are its only discounted processing short of the Batch API. I wanted to know how long the wait is and what else changes when you ask for one.
What I ran
Saturday 21 November, 09:20 to 10:27 Amsterdam time, the small hours in the US. In total 236 requests to /v1/responses, of which 167 were accepted, for about $0.57 at the published rates.
The timing runs used a one-line prompt on Luna, Sol and Terra. The cache runs used a made-up policy handbook of 7,426 tokens on GPT-6.2 Sol. Every duration below is the server's own: completed_at minus created_at.
Two hours turned out to be five minutes
| Request | Count | Fastest | Median | Slowest |
|---|---|---|---|---|
| Background, default window | 13 | 2 s | 3 s | 16 s |
2h, first request |
58 | 302 s | 303 s | 393 s |
2h, reused continuation_id |
42 | 5 s | 7 s | 15 s |
8h, first request |
28 | none finished in 65 minutes |
No 2h request finished in under 302 seconds, and 54 of the 58 were done within 322. That looks like a fixed five-minute hold. A real queue would spread out more. OpenAI promises a target of two hours and nothing more, and I measured at a quiet hour, so I wouldn't count on five minutes on a weekday afternoon.
The eight-hour window I can only report as a wait. I sent 28 requests on four models between 09:21 and 09:40. At 10:26, 65 minutes after the first, all 28 were still queued, and I cancelled them. At a quiet hour the 8h hold is longer than an hour, and my follow-up and cache tests for that window never got a first answer.
A reused continuation ID skips the hold
The guide says that reusing background_options.continuation_id on follow-up requests makes them eligible for higher queue priority. In my runs that meant seconds.
I sent ten first requests, each with its own ID. When one finished I sent two more at the same moment: a follow-up carrying the same ID and previous_response_id, and a new request with neither. The follow-ups took 5 to 15 seconds. The new requests took 302 to 312.
The priority comes from the ID alone:
- Same ID and no
previous_response_id, including prompts that had nothing to do with the first: 5 to 10 seconds, 26 of 26. previous_response_idwithout the ID: 303 to 334 seconds.- Same ID on a different model: 304 and 306 seconds.
- Same ID sent 5, 15 and 30 minutes after the first request finished: 6 to 13 seconds, 6 of 6.
An eleven-step run on Luna, one request after the other on a single ID, took 404 seconds end to end: 305 for the first step, 6 to 10 for each of the other ten.
Two limits are in neither the guide nor the API reference. Both arrive as an HTTP 400.
An ID takes one request at a time. I sent 20 at once on an ID that had already been used. One ran, and 19 came back with "This continuation_id already has the maximum number of queued or running requests." An agent that returns two tool results in parallel will hit this.
I also hit it by being quick. Of 23 follow-ups sent as soon as my poller saw the previous step as completed, 5 were refused. The four I retried half a second later went through.
An ID also belongs to one window. A 2h ID on an 8h request returned "This continuation_id is already associated with a different completion_window."
The window has its own prompt cache
The guide gives this one sentence: Standard requests can't reuse cache entries created by 2h or 8h requests. I sent the same 7,426-token prompt twice, in each combination.
| First request | Second request | Cached tokens read |
|---|---|---|
| Standard | Standard | 7,426 |
| Standard | Background, default window | 7,425 |
| Background, default window | Standard | 7,426 |
| Standard | 2h |
0 (3 of 3) |
2h |
Standard | 0 (2 of 2) |
2h |
Background, default window | 0 |
2h |
2h |
7,425 (3 of 3) |
The split runs in both directions, and every miss was a full cache write. The 8h rows are missing because no 8h request finished.
On GPT-6.2 Sol a cache read costs $0.10 per million tokens and a cache write $2.50. Reading my prefix on Standard is $0.0007. The first 2h request wrote it again, which at 30% off is $0.0130, about 17 times as much.
I priced an eleven-step run on Sol from its token counts: one write of 7,427 tokens, then ten steps that each read 7,404 cached tokens and returned 5.
| Where the run goes | Input and output cost |
|---|---|
| Standard, nothing cached yet | $0.0272 |
2h, nothing cached yet |
$0.0190 |
| Standard, prefix already warm | $0.0094 |
With a cold cache on both sides the window is 30% cheaper, as advertised. If live traffic already keeps the prefix warm on Standard, moving the run to 2h doubles its cost.
My steps returned five tokens each, which is the worst case for the window. At 1,000 output tokens per step the 2h run is ahead of a warm Standard cache from the fourth step.
What the response leaves out
The Response object has no field for the completion window. A finished 2h response reports service_tier: "default" and billing: {"payer": "developer"}, the same as a Standard one. If you want to check later which requests ran at a discount, write the window into metadata yourself.
With store: false, both of my 2h results could be fetched for about ten minutes after they completed. After that the API returned 404. A request can finish at any point in its window, so a poller on a 15-minute schedule can miss the answer you paid for. The data controls guide says Zero Data Retention projects get store: false on these windows whatever they send.
Validation is strict. stream: true, service_tier: "flex" or "priority", a missing background: true and three unsupported models (GPT-6.1 Sol, GPT-6 Sol, GPT-5.6 Luna) all returned a 400. Nothing ran at full price by accident. A request I cancelled while queued reported zero tokens.
The typed parameter arrived in openai-python 3.53.0 and openai-node 7.58.0, both on 17 November. An older Python SDK can pass it through extra_body.
How I'd use it
For independent jobs that can wait, the 2h window is an easy 30%. If a day is fine, Batch still gives 50%.
For an agent run, use one continuation_id per run and send one request at a time. Retry the "maximum number" 400 after half a second.
Before moving the background half of a workload, check what shares its prompt prefix. If live traffic keeps that prefix warm on Standard, the windowed requests start cold and pay for the write.
Put the window in metadata. Leave store on, or fetch the result as soon as the webhook fires.
What I didn't test
Weekday hours in the US. The invoice: my API key can't read costs, so the discount comes from the pricing page and the dollar figures are token counts times published rates. Webhooks, a Zero Data Retention project, long outputs, and Astra beyond one request. And the eight-hour window past its first hour.


