+150 XP

ChatGPT · Security, privacy, and data controls

Cutaway office building where a robot receptionist reaches into every floor while an envelope slips past the guard.

The moment you connect Google Drive as an app in ChatGPT or upload a customer spreadsheet for data analysis, your company's data lives in someone else's system. The rules that govern it differ by account type. This lesson covers which rules apply to you, what gets used for training, and how to set up ChatGPT so you can use Actions and apps at work without leaking anything.

The line that actually matters: who controls training

Ignore the marketing tiers for a second. The most important distinction is whether your content can be used to train OpenAI's models by default.

Consumer plans (Free, Go, Plus, Pro): by default, your conversations and uploads *may* be used to improve models. You can turn this off under Settings → Data Controls → Improve the model for everyone. Switching it off keeps your chat history. If you want a conversation that skips history and memory entirely, use Temporary Chat.

Business plans (ChatGPT Business, formerly Team; Enterprise; Edu) and the API: business content is not used to train OpenAI models by default. This is a contractual commitment. Nobody has to remember to flip a toggle. The same applies to the OpenAI API.

The simple mental model:

  • Personal account on default settings: assume it may train. Opt out if you care.
  • Business, Enterprise, Edu, or API: no training on your data by default.

The official statement lives on the Enterprise privacy page and in the API data usage docs. Read them once. They are the source of truth, and plan names on them do change.

"Not used for training" is not the same as "not stored"

Data excluded from training still passes through OpenAI's systems. It is usually retained for a limited window for abuse monitoring and operations. On the API, standard retention is around 30 days, then deletion. Eligible enterprise use cases can apply for Zero Data Retention (ZDR), which means nothing is stored after the request completes.

Legal obligations can override these windows. In 2025, a court preservation order in the New York Times lawsuit temporarily required OpenAI to keep some consumer and API data it would normally delete. Enterprise and ZDR customers were excluded. The lesson for you: deletion policies are commitments made under normal conditions. Your contract and DPA are what hold under abnormal ones.

So "won't train on it" answers the IP question. How long data is stored, and who can see it, is a separate question you answer with retention settings, ZDR, and your contract.

Where data actually goes when you use Actions and apps

People get surprised here. Once you add tools, ChatGPT stops being a sealed box.

Apps (formerly Connectors)

An app such as Google Drive, SharePoint, GitHub, or Box gives ChatGPT scoped access to an external system so it can pull context into a chat or power deep research. OpenAI renamed connectors to apps, so you will see both terms in older docs. Two things to internalize:

  1. Data moves at query time. When ChatGPT searches your Drive to answer a question, snippets of those files enter the conversation. From then on, *your ChatGPT account's* data policy governs them, not the source system's.
  2. Admins control which apps are available. In Business and Enterprise workspaces, an admin enables apps centrally. If you are setting this up for a team, allow only the systems you have actually vetted. Some apps can also write, for example by creating a document or a ticket, so check each one's permissions.

See the current list and behavior in the ChatGPT help center.

GPT Actions

An Action lets a custom GPT call an external API you define with an OpenAPI schema. **This is the riskiest surface because *you* build the data path.** When a user talks to your GPT, ChatGPT can send conversation content to whatever endpoint your Action points at.

The controls that matter:

  • Auth: use OAuth or API-key auth in the Action config. Never hardcode a secret into instructions.
  • Scope: the endpoint should do only what the GPT needs. A "look up order status" Action has no business exposing a "delete customer" route.
  • Data minimization: your Action receives whatever the model decides to send. Validate and sanitize on your server.

Here is a minimal Action schema fragment. Note the explicit input constraint and the read-only, single-purpose route:

yaml
openapi: 3.1.0
info:
  title: Order Status
  version: "1.0"
servers:
  - url: https://api.example.com
paths:
  /orders/{id}/status:
    get:
      operationId: getOrderStatus
      summary: Return shipping status for one order
      parameters:
        - name: id
          in: path
          required: true
          schema: { type: string, pattern: "^[A-Z0-9]{8,12}$" }
      responses:
        "200":
          description: Status found
          content:
            application/json:
              schema:
                type: object
                properties:
                  status: { type: string }
                  eta: { type: string, format: date }

The pattern constraint is a small but real control. It stops the model from sending malformed or injected IDs to your backend. Your server should still enforce the same check.

ChatGPT agent, Codex, and scheduled tasks

ChatGPT agent can browse, click, and act for you, which means it can submit forms and move data on its own. Codex works on code repositories and can open pull requests. Scheduled tasks run prompts on a timer, sometimes while you are away.

Risk rises with autonomy. An agent that can act on a connected system can be steered by prompt injection: malicious text hidden in a web page, email, or document that tries to hijack the agent's instructions. Any autonomous run that touches sensitive systems should require human approval. Use read-only access for anything experimental.

Memory, custom instructions, and Projects

These features persist data across chats, so give them a security pass.

  • Memory stores facts the model learns about you across conversations. If you paste a client's data into a chat, memory could retain a summary of it. Review and clear memory in Settings → Personalization. In Enterprise workspaces, admins can govern this.
  • Custom instructions are sent with every message. Keep secrets and full client names out of them.
  • Projects keep files and chats grouped together, and they are a good control. Put each client's documents in their own Project instead of scattering them across your whole history.

ChatGPT Enterprise Data Privacy & Security Explained

Watch on YouTube

Custom gpts and GPT store exposure

If you publish a custom GPT to the GPT Store, know what leaks and what doesn't:

  • Determined users can partially reconstruct your instructions and configuration. A system prompt is not a secret vault.
  • Users can sometimes extract uploaded knowledge files through clever prompting. Never attach a file to a public GPT that you would not hand to a stranger.
  • *Their* account settings and OpenAI's policies govern the conversations users have with your GPT. Yours do not.

For internal GPTs, set sharing to "Only people in my workspace." That one setting decides whether you have a private tool or a public one.

Knowledge check

1. According to the lesson, what is the single most important distinction to focus on when evaluating how ChatGPT handles your data?

2. A colleague on a free consumer account is worried their uploads might be used for model training. What is the correct guidance?

3. Why does the lesson stress that 'not used for training' is different from 'not stored'?

MULTIPLE CHOICE

4. Select ALL statements that correctly describe how business plans and the API handle training on your data.

Select all the correct answers.

MULTIPLE CHOICE

5. Select ALL correct statements about Zero Data Retention (ZDR) and API retention as described in the lesson.

Select all the correct answers.

A simple rule for safe use at work

You do not need a 40-page policy. You need one rule that holds up under pressure:

If the data is regulated, secret, or someone else's, it only goes into a workspace that contractually excludes training and that an admin controls. Everything else can go in your personal account.

Unpacked:

  • Regulated data covers health records, financial data, and personal data under GDPR or HIPAA-style rules. Use a business workspace only, and check your DPA.
  • Secret data includes unreleased products, source code, strategy, and credentials. Keep it in a business workspace, and never put it in custom instructions or public GPTs.
  • Someone else's data means client data, partner data, and anything you are contractually bound to protect. Use a business workspace, ideally scoped to a Project.

If none of those apply, say you are drafting a blog post or summarizing a public article, your personal account is fine.

Applying the rule to the API

On the API the same principle holds, and you also own the system prompt and retention configuration. Use structured outputs to constrain what the model returns. That way a downstream system never receives free-form text it might mishandle. Here is a request that forces a strict schema:

python
from openai import OpenAI

client = OpenAI()

resp = client.responses.create(
    model="gpt-5-mini",
    input="Extract the order ID and status from: 'Order AB12CD34 shipped today.'",
    text={
        "format": {
            "type": "json_schema",
            "name": "order",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                    "status": {"type": "string"},
                },
                "required": ["order_id", "status"],
                "additionalProperties": False,
            },
        }
    },
)

print(resp.output_text)

With strict: True and additionalProperties: False, the model cannot slip extra fields into your pipeline. This is a privacy control as much as a correctness one, because it bounds exactly what data crosses your system boundary.

If you build agents

With function calling or the Agents SDK, every tool you give a model is a data egress point. Apply least privilege to each function, the same way as with the YAML Action above:

  • Give each function a narrow scope.
  • Validate its inputs.
  • Add a human checkpoint before anything irreversible or sensitive.

The model decides *when* to call a tool. Your code is still responsible for checking *what* it sends.

Quick admin checklist for a team rollout

If you are the person turning ChatGPT on for colleagues:

  1. Use a Business or Enterprise workspace, so training exclusion is contractual rather than left to each user.
  2. Enable only vetted apps, and prefer read-only permissions.
  3. Set custom GPT sharing defaults to workspace-only.
  4. Decide your memory and retention posture, and ask about ZDR if you handle regulated data through the API.
  5. Publish the one-sentence rule above to every user. Short policies get followed.

Key Takeaways

  • Tier determines training by default. Personal accounts (Free, Go, Plus, Pro) may train on your data unless you opt out. Business, Enterprise, Edu, and the API exclude it contractually. Confirm on the Enterprise privacy page.
  • "Not trained on" is not "not stored." Ask about retention windows, ZDR, and legal holds separately when data is sensitive.
  • Actions and apps (formerly connectors) are data exits. Give each one narrow scope, real auth, and validated inputs. Treat agents, Codex, and scheduled tasks as higher risk, and require human approval.
  • Projects and workspace-only sharing contain client files, keeping them out of your wider history and off the public GPT Store.
  • Carry one rule: regulated, secret, or someone else's data goes only into an admin-controlled workspace that excludes training.

Frequently asked questions

Does OpenAI train its models on what I type into ChatGPT?

It depends on your account type. On consumer plans (Free, Go, Plus, Pro), conversations and uploads may be used to improve models by default, and you have to opt out under Settings → Data Controls → Improve the model for everyone. On ChatGPT Business, Enterprise, Edu and the OpenAI API, content is excluded from training by contract, with no toggle to remember.

If my data isn't used for training, does that mean OpenAI doesn't store it?

No. Data excluded from training still passes through OpenAI's systems and is usually retained for a limited window for abuse monitoring and operations; on the API, standard retention is around 30 days before deletion. Eligible enterprise use cases can request Zero Data Retention, where nothing is kept once the request completes. Training exclusion answers the intellectual property question, retention and access are a separate conversation to have with your contract and DPA.

What's the difference between an app (connector) and a GPT Action in ChatGPT?

An app, previously called a connector, gives ChatGPT scoped read access to an external system like Google Drive, SharePoint, GitHub or Box so it can pull context into a conversation, and admins choose which ones are available. A GPT Action is an external API you define yourself with an OpenAPI schema, so you build the data path and decide what the endpoint exposes. Actions are the riskier surface because ChatGPT can send conversation content to whatever endpoint you point it at.

Can I put client or regulated data into ChatGPT at work?

Only in a workspace that contractually excludes training and that an admin controls, which means ChatGPT Business, Enterprise or Edu rather than a personal account. That rule covers regulated data (health, financial, personal data under GDPR or HIPAA-style rules), secret data (unreleased products, source code, strategy, credentials) and anything belonging to a client or partner. For client files, group them in a dedicated Project so they stay out of your wider chat history.

How do I secure a GPT Action so it doesn't leak data to my backend?

Use OAuth or API-key authentication in the Action configuration and never hardcode a secret into the GPT instructions. Keep each endpoint single-purpose and read-only where possible: an order-status lookup should not expose a delete-customer route. Constrain inputs in the OpenAPI schema with patterns or types, and re-validate the same rules server-side, because your Action receives whatever the model decides to send.

What are the risks of publishing a custom GPT on the GPT Store?

Determined users can partially reconstruct your instructions and configuration, so a system prompt is not a secret vault, and uploaded knowledge files can sometimes be extracted through clever prompting. Never attach a document you would not hand to a stranger. Conversations users have with your published GPT are governed by their account settings and OpenAI's policies, not yours; for internal tools, set sharing to "Only people in my workspace".

What to do, from this lesson

These actions are compiled in the role's Playbook.

  • Run one Project per client, scoping files and instructions to it
  • Own team GPTs at workspace/admin level and publish workspace-only
See the full action playbook →

Related articles

Recent articles from the blog that build on this lesson.