---
title: What does the OpenAI Responses API store, and how do you turn it off for agents?
url: https://opencontroller.lyzr.com/blog/openai-responses-api-store-and-agent-data-retention
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# What does the OpenAI Responses API store, and how do you turn it off for agents?

**By default the OpenAI Responses API stores responses as application state for 30 days so you can retrieve them and chain turns with `previous_response_id`. Setting `store` to `false` stops that, but then your agent must send prior context itself, and reasoning models need `reasoning.encrypted_content` included to carry reasoning across turns. Abuse monitoring logs are a separate retention of up to 30 days that `store` does not change; only approved Zero Data Retention or Modified Abuse Monitoring changes those.**

Teams moving agents from Chat Completions to the Responses API are often surprised that conversation data now persists on OpenAI's side by default. This post explains what is stored, for how long and what to configure. The source of truth is OpenAI's [data controls guide](https://developers.openai.com/api/docs/guides/your-data) and the [Responses API reference](https://developers.openai.com/api/reference/resources/responses/methods/create); check both for changes.

See also the [AI agent control plane](/blog/what-is-an-ai-agent-control-plane) pillar for how data controls fit into wider agent governance.

## What is retained, endpoint by endpoint?

| Endpoint | Application state by default | Abuse monitoring logs | ZDR eligible |
|---|---|---|---|
| `/v1/responses` | 30 days when stored | Up to 30 days unless law requires longer | Yes, with limitations; `store` is treated as `false` |
| `/v1/chat/completions` | None (exceptions such as audio outputs, kept 1 hour) | Up to 30 days | Yes, with limitations |
| `/v1/conversations` | Until deleted | Until deleted | No |

Two other retention points matter for agents:

- **Background mode.** Background responses are stored for roughly 10 minutes so you can poll for the result, even if `store` is omitted or false.
- **Prompt caching.** Cached key/value data may be held in GPU-local storage and is not retained after its 24-hour expiry.

## What changes when you set `store` to `false`?

1. **No retrievable response object.** You cannot fetch the response later by ID.
2. **No `previous_response_id` chaining.** The agent or your gateway must keep conversation history and send it with each request.
3. **Reasoning continuity needs encryption.** The API reference says including `reasoning.encrypted_content` returns an encrypted version of reasoning tokens in reasoning items, so they can be used in multi-turn conversations when using the Responses API statelessly, for example with `store` false or under zero data retention. Pass those items back on the next turn.
4. **Hosted tool state.** Features that depend on stored state, such as server-side conversation objects, are not available in the same way. Check OpenAI's list of features excluded from ZDR, summarised in [LLM API features excluded from zero data retention](/blog/llm-api-features-excluded-from-zero-data-retention).

## Which setting should an agent use?

| Situation | Recommended setup |
|---|---|
| Internal agent, no personal or regulated data | Default `store` true is acceptable; set a deletion process for stored responses |
| Agent handles personal, financial or health data | `store` false, history kept in your own store, `reasoning.encrypted_content` included |
| Regulated workload that must not leave content with the provider | Apply for Zero Data Retention or Modified Abuse Monitoring; confirm every feature you use is eligible |
| Long-running tasks using background mode | Accept the short polling retention or avoid background mode for sensitive data |

Data location is a separate question from retention. See [OpenAI API data residency for agents](/blog/openai-api-data-residency-for-agents).

## How do you enforce this across many agents?

Setting `store` per request depends on every developer remembering. Three ways to enforce it centrally:

1. **Project-level controls.** Use separate OpenAI projects for sensitive agents and apply the organisation's data controls there.
2. **Gateway enforcement.** Route Responses API traffic through a gateway that sets or rejects `store` values according to the agent's data classification, and logs which agents send `store` true.
3. **Inventory and review.** Keep a list of agents using the Responses API, their data classification and their `store` setting, and review it when OpenAI changes retention terms.

If you use the OpenAI Agents SDK, tracing has its own data controls; see [OpenAI Agents SDK tracing data controls](/blog/openai-agents-sdk-tracing-data-controls).

## How Opencontroller does this

Opencontroller connects to OpenAI Enterprise workspaces and auto-discovers models and API keys, so you can see which agents call OpenAI and with which keys. Its LLM Gateway exposes OpenAI-compatible endpoints and works in the path, so it can allow, route, redact or block requests by policy, and it attributes cost per agent and per version. Policies are written as code, so a rule such as "agents classified as confidential must not send `store` true" can be expressed and reported on. [Book a demo](https://www.lyzr.ai/book-demo/) to review your OpenAI data settings.

## Frequently asked questions

**How long does the OpenAI Responses API keep responses by default?**
Application state is retained for 30 days by default when responses are stored. Abuse monitoring logs are kept for up to 30 days unless law requires longer.

**Does `store=false` stop OpenAI keeping abuse monitoring logs?**
No. `store` controls application state. Abuse monitoring retention changes only with approved Zero Data Retention or Modified Abuse Monitoring.

**Can I use `previous_response_id` with `store=false`?**
No. Without stored state, send prior context yourself, and include `reasoning.encrypted_content` to carry reasoning across turns for reasoning models.

## Key facts

OpenAI Responses API: application state retained 30 days by default when store is true (store defaults to true); abuse monitoring logs up to 30 days unless law requires longer. Chat Completions: no application state by default (audio outputs 1 hour). Conversations API: state and abuse logs kept until deleted; not ZDR eligible. Responses and Chat Completions are ZDR eligible with limitations; under ZDR store is treated as false. Background mode stores responses roughly 10 minutes for polling. Prompt cache data held in GPU-local storage up to 24-hour expiry. With store=false: no retrieval, no previous_response_id chaining; include reasoning.encrypted_content to carry reasoning statelessly. Opencontroller connects to OpenAI Enterprise workspaces, discovers models and API keys, and its LLM Gateway (OpenAI-compatible) can allow, route, redact or block with policy as code and cost attribution per agent and version.

## Related

- [Which LLM API features are excluded from zero data retention?](https://opencontroller.lyzr.com/blog/llm-api-features-excluded-from-zero-data-retention.md)
- [How does OpenAI API data residency work for AI agents?](https://opencontroller.lyzr.com/blog/openai-api-data-residency-for-agents.md)
- [Where does OpenAI Agents SDK tracing send your data?](https://opencontroller.lyzr.com/blog/openai-agents-sdk-tracing-data-controls.md)
- [More on Platform Guides](https://opencontroller.lyzr.com/blog/cluster/platform-guides)
