Agents like Codex and Deep Research show that reasoning models can take several minutes to solve complex problems. Background mode enables you to execute long-running tasks on models like GPT-5.2 and GPT-5.2 Pro reliably, without having to worry about timeouts or other connectivity issues.
Background mode kicks off these tasks asynchronously, and developers can poll response objects to check status over time. To start response generation in the background, make an API request with background set to true:
Because background mode stores response data for roughly 10 minutes to enable
polling, it is not Zero Data Retention (ZDR) compatible. Requests from ZDR
projects are still accepted with background=true for legacy reasons, but
using it breaks ZDR guarantees. Modified Abuse Monitoring (MAM) projects can
safely rely on background mode.
1
2
3
4
5
6
7
8
9
10
11
from openai import OpenAI
client = OpenAI()
resp = client.responses.create(
model="gpt-5.5",
input="Write a very long novel about otters in space.",
background=True,
)
print(resp.status)To check the status of background requests, use the GET endpoint for Responses. Keep polling while the request is in the queued or in_progress state. When it leaves these states, it has reached a final (terminal) state.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from openai import OpenAI
from time import sleep
client = OpenAI()
resp = client.responses.create(
model="gpt-5.5",
input="Write a very long novel about otters in space.",
background=True,
)
while resp.status in {"queued", "in_progress"}:
print(f"Current status: {resp.status}")
sleep(2)
resp = client.responses.retrieve(resp.id)
print(f"Final status: {resp.status}\nOutput:\n{resp.output_text}")You can also cancel an in-flight response like this:
1
2
3
4
5
6
from openai import OpenAI
client = OpenAI()
resp = client.responses.cancel("resp_123")
print(resp.status)Cancelling twice is idempotent - subsequent calls simply return the final Response object.
You can create a background Response and start streaming events from it right away. This may be helpful if you expect the client to drop the stream and want the option of picking it back up later. To do this, create a Response with both background and stream set to true. You will want to keep track of a “cursor” corresponding to the sequence_number you receive in each streaming event.
Currently, the time to first token you receive from a background response is higher than what you receive from a synchronous one. We are working to reduce this latency gap in the coming weeks.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from openai import OpenAI
client = OpenAI()
# Fire off an async response but also start streaming immediately
stream = client.responses.create(
model="gpt-5.5",
input="Write a very long novel about otters in space.",
background=True,
stream=True,
)
cursor = None
for event in stream:
print(event)
cursor = event.sequence_number
# If your connection drops, the response continues running and you can reconnect:
# SDK support for resuming the stream is coming soon.
# for event in client.responses.stream(resp.id, starting_after=cursor):
# print(event)- Background sampling requires
store=true; stateless requests are rejected. - To cancel a synchronous response, terminate the connection
- You can only start a new stream from a background response if you created it with
stream=true.