# Add the response to the conversation
history += [{"role": el.role, "content": el.content} for el in response.output]

history.append({ "role": "user", "content": "tell me another" })

second_response = client.responses.create(
    model="gpt-4o-mini",
    input=history,
    store=False
)

print(second_response.output_text)
```

## OpenAI APIs for conversation state

Our APIs make it easier to manage conversation state automatically, so you don't
have to do pass inputs manually with each turn of a conversation.

### Using the Conversations API

The
[Conversations API](https://platform.openai.com/docs/api-reference/conversations/create)
works with the
[Responses API](https://platform.openai.com/docs/api-reference/responses/create)
to persist conversation state as a long-running object with its own durable
identifier. After creating a conversation object, you can keep using it across
sessions, devices, or jobs.

Conversations store items, which can be messages, tool calls, tool outputs, and
other data.

```python
conversation = openai.conversations.create()
```

In a multi-turn interaction, you can pass the `conversation` into subsequent
responses to persist state and share context across subsequent responses, rather
than having to chain multiple response items together.

```python
response = openai.responses.create(
  model="gpt-4.1",
  input=[{"role": "user", "content": "What are the 5 Ds of dodgeball?"}]
  conversation: "conv_689667905b048191b4740501625afd940c7533ace33a2dab"
)
```

### Passing context from the previous response

Another way to manage conversation state is to share context across generated
responses with the `previous_response_id` parameter. This parameter lets you
chain responses and create a threaded conversation.

```javascript
import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-4o-mini",
  input: "tell me a joke",
  store: true,
});

console.log(response.output_text);

const secondResponse = await openai.responses.create({
  model: "gpt-4o-mini",
  previous_response_id: response.id,
  input: [{ role: "user", content: "explain why this is funny." }],
  store: true,
});

console.log(secondResponse.output_text);
```

```python
from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-4o-mini",
    input="tell me a joke",
)
print(response.output_text)

second_response = client.responses.create(
    model="gpt-4o-mini",
    previous_response_id=response.id,
    input=[{"role": "user", "content": "explain why this is funny."}],
)
print(second_response.output_text)
```

In the following example, we ask the model to tell a joke. Separately, we ask
the model to explain why it's funny, and the model has all necessary context to
deliver a good response.

```javascript
import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.responses.create({
  model: "gpt-4o-mini",
  input: "tell me a joke",
  store: true,
});

console.log(response.output_text);

const secondResponse = await openai.responses.create({
  model: "gpt-4o-mini",
  previous_response_id: response.id,
  input: [{ role: "user", content: "explain why this is funny." }],
  store: true,
});

console.log(secondResponse.output_text);
```

```python
from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-4o-mini",
    input="tell me a joke",
)
print(response.output_text)

second_response = client.responses.create(
    model="gpt-4o-mini",
    previous_response_id=response.id,
    input=[{"role": "user", "content": "explain why this is funny."}],
)
print(second_response.output_text)
```

Data retention for model responses

Response objects are saved for 30 days by default. They can be viewed in the
dashboard [logs](/logs?api=responses) page or
[retrieved](https://platform.openai.com/docs/api-reference/responses/get) via
the API. You can disable this behavior by setting `store` to `false` when
creating a Response.

Conversation objects and items in them are not subject to the 30 day TTL. Any
response attached to a conversation will have its items persisted with no 30 day
TTL.

OpenAI does not use data sent via API to train our models without your explicit
consentâ[learn more](https://platform.openai.com/docs/guides/your-data).

Even when using `previous_response_id`, all previous input tokens for responses
in the chain are billed as input tokens in the API.

## Managing the context window

Understanding context windows will help you successfully create threaded
conversations and manage state across model interactions.

The **context window** is the maximum number of tokens that can be used in a
single request. This max tokens number includes input, output, and reasoning
tokens. To learn your model's context window, see
[model details](https://platform.openai.com/docs/models).

### Managing context for text generation

As your inputs become more complex, or you include more turns in a conversation,
you'll need to consider both **output token** and **context window** limits.
Model inputs and outputs are metered in tokens, which are parsed from inputs to
analyze their content and intent and assembled to render logical outputs. Models
have limits on token usage during the lifecycle of a text generation request.

- **Output tokens** are the tokens generated by a model in response to a prompt.
  Each model has different
  [limits for output tokens](https://platform.openai.com/docs/models). For
  example, `gpt-4o-2024-08-06` can generate a maximum of 16,384 output tokens.
- A **context window** describes the total tokens that can be used for both
  input and output tokens (and for some models,
  [reasoning tokens](https://platform.openai.com/docs/guides/reasoning)).
  Compare the [context window limits](https://platform.openai.com/docs/models)
  of our models. For example, `gpt-4o-2024-08-06` has a total context window of
  128k tokens.

If you create a very large promptâoften by including extra context, data, or
examples for the modelâyou run the risk of exceeding the allocated context
window for a model, which might result in truncated outputs.

Use the [tokenizer tool](/tokenizer), built with the tiktoken library, to see
how many tokens are in a particular string of text.

For example, when making an API request to the
[Responses API](https://platform.openai.com/docs/api-reference/responses) with a
reasoning enabled model, like the
[o1 model](https://platform.openai.com/docs/guides/reasoning), the following
token counts will apply toward the context window total:

- Input tokens (inputs you include in the `input` array for the
  [Responses API](https://platform.openai.com/docs/api-reference/responses))
- Output tokens (tokens generated in response to your prompt)
- Reasoning tokens (used by the model to plan a response)

Tokens generated in excess of the context window limit may be truncated in API
responses.

![context window visualization](https://cdn.openai.com/API/docs/images/context-window.png)

You can estimate the number of tokens your messages will use with the
[tokenizer tool](/tokenizer).

## Next steps

For more specific examples and use cases, visit the OpenAI Cookbook, or learn
more about using the APIs to extend model capabilities:

- [Receive JSON responses with Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
- [Extend the models with function calling](https://platform.openai.com/docs/guides/function-calling)
- [Enable streaming for real-time responses](https://platform.openai.com/docs/guides/streaming-responses)
- [Build a computer using agent](https://platform.openai.com/docs/guides/tools-computer-use)