Last updated: March 15, 2026

AI companies collect and use your conversations to train their models. If you’ve ever shared personal information, code, or sensitive business data with ChatGPT, Microsoft Copilot (formerly Bing AI), or Google Gemini (formerly Bard), that data may already be incorporated into their training pipelines. Here’s how to exercise your rights and remove your data from AI training in 2026.

Prerequisites

Before you begin, make sure you have the following ready:

Step 1 - Understand What Data AI Companies Collect

Before removing your data, understand what’s actually stored:

OpenAI (ChatGPT) stores conversation history, IP addresses, device information, and may use interactions for model training unless you opt out. Microsoft Copilot collects prompts, search history, and location data tied to your Microsoft account. Google Gemini stores conversation history, account information, and may use interactions to improve Google’s language models.

Under GDPR (for EU residents), CCPA (California), and similar privacy regulations, you have the right to request deletion of your personal data from training models. Remove Your Data From OpenAI (ChatGPT)

OpenAI provides two methods for controlling your data: account settings and direct API deletion requests.

Method 1 - Disable Training in ChatGPT Settings

If you use the web interface, navigate to Settings → Data Controls and toggle off “Improve the model for everyone.” This prevents future conversations from being used in training.

// Check your current settings via ChatGPT web
// Navigate to: https://chatgpt.com/settings
// Click "Data Controls"
// Disable "Improve the model for everyone"

Method 2 - Delete Conversation History

Delete specific conversations to remove them from your active history. Note that this doesn’t guarantee removal from already-trained models, but prevents future training.

Using OpenAI API to delete a conversation (hypothetical endpoint)
import requests

def delete_chatgpt_conversation(conversation_id: str, api_key: str) -> dict:
    """
    Delete a conversation from ChatGPT history.
    This removes it from your visible history but
    may not remove it from training datasets.
    """
    response = requests.delete(
        "https://api.openai.com/v1/conversations/{}".format(conversation_id),
        headers={
            "Authorization": "Bearer {}".format(api_key),
            "Content-Type": "application/json"
        }
    )
    return response.json()

Method 3 - Submit a Data Deletion Request

For complete removal from training data, submit a formal request to OpenAI:

  1. Visit https://help.openai.com/en/collections/37407-data-privacy-and-security
  2. Look for “Delete my data” or “Data deletion request”
  3. Alternatively, email privacy@openai.com with:
    • Your account email
    • Request type: “Delete my data from training models”
    • Specific data types to remove
Example curl request format for data deletion
curl -X POST "https://api.openai.com/v1/privacy/delete" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user_id": "your-user-id",
    "request_type": "training_data_removal",
    "data_categories": ["conversations", "model_outputs", "feedback"]
  }'

Step 3 - Remove Your Data From Microsoft Copilot (Bing AI)

Microsoft provides privacy controls through your Microsoft account and explicit opt-out mechanisms.

Method 1 - Disable AI Training in Microsoft Privacy Settings

Navigate to https://account.microsoft.com/privacy and adjust the following:

Method 2 - Clear Bing/Copilot History

Clear Bing search history via Microsoft Privacy API
import requests

def clear_microsoft_search_history(access_token: str) -> bool:
    """
    Clear Microsoft search and AI interaction history.
    Requires Microsoft account with appropriate permissions.
    """
    # First, get history
    history_response = requests.get(
        "https://api.bing.com/osjson.aspx?action=history",
        headers={"Authorization": "Bearer {}".format(access_token)}
    )

    # Then delete each item
    for item in history_response.json().get("items", []):
        requests.delete(
            "https://api.bing.com/osjson.aspx",
            params={"action": "delete", "id": item["id"]},
            headers={"Authorization": "Bearer {}".format(access_token)}
        )

    return True

Method 3 - Submit GDPR Deletion Request

For EU residents or California residents:

  1. Visit https://account.microsoft.com/privacy
  2. Scroll to “Cortana and search”
  3. Select “Delete my data”
  4. Or submit via https://www.microsoft.com/en-us/concern/privacy

Microsoft provides a dedicated privacy dashboard for AI data:

// Microsoft Privacy API - Delete Copilot data
async function deleteCopilotData(accessToken) {
  const response = await fetch(
    'https://api.privacy.microsoft.com/v1.0/user/aiData/delete',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        dataTypes: [
          'copilot_conversations',
          'bing_search_history',
          'ai_model_feedback'
        ],
        requestReason: 'GDPR Article 17 - Right to Erasure'
      })
    }
  );

  return response.json();
}

Step 4 - Remove Your Data From Google Gemini (Bard)

Google provides data controls through your Google Account and My Activity dashboard.

Method 1 - Delete Gemini Activity

  1. Visit https://myactivity.google.com/product/gemini
  2. Select “Delete activity by”
  3. Choose time range or specific conversations
  4. Confirm deletion

Method 2 - Configure Auto-Delete

Set Google to automatically delete AI activity:

Google Takeout API - Configure auto-delete for AI activity
from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build

def configure_gemini_autodelete(credentials, days: int = 3):
    """
    Configure automatic deletion of Gemini activity.
    Options: 3 months, 18 months, 36 months, or manual
    """
    service = build('myactivity', 'v1', credentials=credentials)

    # Note: This uses Google's Activity Controls API
    settings = {
        "kind": "myactivity#activitySettings",
        "geminiAutoDelete": {
            "enabled": True,
            "retentionPeriod": "{} days".format(days)
        }
    }

    result = service.settings().update(body=settings).execute()
    return result

Method 3 - Submit Data Deletion Request

Google requires specific requests for model training removal:

  1. Visit https://support.google.com/policies/contact/safety/
  2. Select “Privacy and data” → “Data from AI interactions”
  3. Request deletion of Gemini/Bard conversations from training
  4. Or use https://myaccount.google.com/data-and-privacy → “More options” → “Delete your Google AI activity”
Google Privacy API - Request AI data deletion
curl -X POST "https://myaccount.google.com/privacy/deletion/v2/ai" \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d '{
    "user_id": "YOUR_USER_ID",
    "deletion_scope": "gemini_training_data",
    "include": [
      "bard_conversations",
      "gemini_prompts",
      "model_feedback",
      "training_derived_data"
    ]
  }'

Developer Best Practices for AI Privacy

For developers building applications that integrate with these AI services, consider these patterns:

Implement Local Data Control

Store user preferences for AI data handling
class UserAIPreferences:
    def __init__(self, user_id: str):
        self.user_id = user_id
        self.allow_training = False
        self.auto_delete_days = 30
        self.audit_log = []

    def to_privacy_header(self) -> dict:
        """Generate privacy headers for API calls"""
        return {
            "X-Do-Not-Train": str(not self.allow_training).lower(),
            "X-Auto-Delete-After": str(self.auto_delete_days),
            "X-User-Privacy-Consent": "explicit"
        }

Data Minimization for AI Prompts

Before sending data to AI services, strip identifying information:

import re

def sanitize_for_ai(prompt: str, user_preferences: UserAIPreferences) -> str:
    """
    Remove potential PII from prompts before sending to AI.
    """
    # Remove email addresses
    sanitized = re.sub(r'[\w.-]+@[\w.-]+\.\w+', '[EMAIL]', prompt)

    # Remove phone numbers
    sanitized = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[PHONE]', sanitized)

    # Remove SSN patterns
    sanitized = re.sub(r'\b\d{3}[-]?\d{2}[-]?\d{4}\b', '[SSN]', sanitized)

    # Log the sanitization for audit
    user_preferences.audit_log.append({
        "action": "sanitize",
        "original_length": len(prompt),
        "sanitized_length": len(sanitized)
    })

    return sanitized

Step 5 - What Companies Actually Delete

Be realistic about what these deletion requests accomplish:

The most effective strategy remains prevention: avoid entering sensitive personal information into AI systems in the first place.

Troubleshooting

Configuration changes not taking effect

Restart the relevant service or application after making changes. Some settings require a full system reboot. Verify the configuration file path is correct and the syntax is valid.

Permission denied errors

Run the command with sudo for system-level operations, or check that your user account has the necessary permissions. On macOS, you may need to grant terminal access in System Settings > Privacy & Security.

Connection or network-related failures

Check your internet connection and firewall settings. If using a VPN, try disconnecting temporarily to isolate the issue. Verify that the target server or service is accessible from your network.

Frequently Asked Questions

How long does it take to remove personal data from chatgpt bing ai and google?

For a straightforward setup, expect 30 minutes to 2 hours depending on your familiarity with the tools involved. Complex configurations with custom requirements may take longer. Having your credentials and environment ready before starting saves significant time.

What are the most common mistakes to avoid?

The most frequent issues are skipping prerequisite steps, using outdated package versions, and not reading error messages carefully. Follow the steps in order, verify each one works before moving on, and check the official documentation if something behaves unexpectedly.

Do I need prior experience to follow this guide?

Basic familiarity with the relevant tools and command line is helpful but not strictly required. Each step is explained with context. If you get stuck, the official documentation for each tool covers fundamentals that may fill in knowledge gaps.

Is this approach secure enough for production?

The patterns shown here follow standard practices, but production deployments need additional hardening. Add rate limiting, input validation, proper secret management, and monitoring before going live. Consider a security review if your application handles sensitive user data.

Where can I get help if I run into issues?

Start with the official documentation for each tool mentioned. Stack Overflow and GitHub Issues are good next steps for specific error messages. Community forums and Discord servers for the relevant tools often have active members who can help with setup problems.

Related Articles