DSGVO und Datenschutz mit OpenAI

KI und die DSGVO: Ein unverhandelbarer Rahmen

Die Datenschutz-Grundverordnung (DSGVO) gilt für jede Anwendung, die personenbezogene Daten von europäischen Bewohnern verarbeitet – einschließlich Anwendungen, die auf großen Sprachmodellen (LLMs) basieren. Es gibt keine Ausnahmen für künstliche Intelligenz. Dies verwirrt technische Teams oft: Sie suchen nach KI-spezifischen Vorschriften, während das anwendbare Regelwerk seit Jahren existiert und unverändert geblieben ist. Im Jahr 2026 zielen Durchsetzungsmaßnahmen zunehmend auf KI-Systeme ab. Die Nutzung der OpenAI-APIs in diesem Kontext bedeutet weniger, neues Recht zu lernen, als vielmehr bekannte rechtliche Anforderungen in eine neue Architektur zu übersetzen.

Sieben Grundsätze, übersetzt für ein LLM-System

Die DSGVO basiert auf sieben Kernprinzipien, die jeweils eine spezifische Bedeutung erlangen, sobald ein Sprachmodell in die Verarbeitungs-Kette eintritt.

Zwei Prinzipien überraschen Teams regelmäßig. Erstens Richtigkeit: Dies verwandelt Halluzinationen von einem Qualitätsproblem in ein regulatorisches. Wenn ein Modell falsche Informationen über eine identifizierte Person generiert, hat diese Person ein Recht auf Berichtigung. Zweitens Verantwortlichkeit: Es reicht nicht aus, konform zu sein – Sie müssen dies nachweisen können. Dies verwandelt die Dokumentation von einer Best Practice in eine rechtliche Verpflichtung.

Minimierung: Die Maßnahme, die die meisten Probleme löst

Von allen verfügbaren Maßnahmen bietet die Pseudonymisierung vor dem Versand von Daten das beste Gleichgewicht zwischen Aufwand und Risikominderung. Die Logik ist einfach: Was Ihr System nie verlässt, kann nicht an einen Auftragsverarbeiter gelangen, kann keine Fragen bei Übertragungen außerhalb der EU aufwerfen und wird Löschungsanfragen nicht komplizieren.

Der untenstehende Mechanismus ersetzt jedes identifizierende Datenstück mit einem stabilen Token, behält die Zuordnung im lokalen Speicher und stellt die Originalwerte in der Antwort wieder her. Der Endnutzer sieht „Herr Dupont”, das Modell sieht nur „[PERSON_1]“, und die Service-Funktion bleibt vollständig intakt – der Assistent kann seine Antwort weiterhin entwerfen, da er den tatsächlichen Nachnamen nie benötigt hat.

Der Kommentar zu Namen ist nicht dekorativ: Das Muster erfasst nur Formen, die einem Titel vorausgehen. Ein bloßer Name wird durchrutschen. In der Produktion übernimmt ein Named Entity Recognition (NER)-Modell die Aufgabe, und diese Warnung explizit im Code zu haben, schlägt falsches Vertrauen.

import re

class DataMinimizer:
    """Anonymisiert personenbezogene Daten, bevor sie an die API gesendet werden."""

    def __init__(self):
        self.mappings: dict[str, str] = {}
        self.counter = 0

    def anonymize(self, text: str) -> str:
        """Ersetzt personenbezogene Daten durch Platzhalter."""
        # E-Mails
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # Französische Telefonnummern
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Namen (vereinfachtes Muster – verwenden Sie NER in der Produktion)
        text = re.sub(
            r"\b(Mr\.|Ms\.|Dr\.)\s+[A-Z][a-zéèêë]+\s+[A-Z][a-zéèêë]+\b",
            lambda m: self._replace(m.group(), "PERSON"),
            text,
        )
        # IBAN
        text = re.sub(
            r"\b[A-Z]{2}\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{4}\s?\d{0,4}\b",
            lambda m: self._replace(m.group(), "IBAN"),
            text,
        )
        return text

    def _replace(self, value: str, type_: str) -> str:
        if value not in self.mappings:
            self.counter += 1
            self.mappings[value] = f"[{type_}_{self.counter}]"
        return self.mappings[value]

    def deanonymize(self, text: str) -> str:
        """Stellt ursprüngliche Daten in der Antwort wieder her."
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Nutzung
minimizer = DataMinimizer()

original_message = "Mr. Dupont ([email protected], 06 12 34 56 78) requests a refund."
anonymized_message = minimizer.anonymize(original_message)
print(f"An die API gesendet: {anonymized_message}")
# "[PERSON_1] ([EMAIL_1], [PHONE_1]) requests a refund."

# Nach Modellantwort
model_response = "The file for [PERSON_1] has been processed. An email was sent to [EMAIL_1]."
final_response = minimizer.deanonymize(model_response)
print(f"Endgültige Antwort: {final_response}")

Konfigurieren Sie den Dienst und sammeln Sie Einwilligungen

Auf der Anbieterseite gilt diese Regel: Daten, die über die API gesendet werden, werden standardmäßig nicht für das Training verwendet, im Gegensatz zu dem, was viele durch Analogie zu Consumer-Schnittstellen annehmen. Dies befreit Sie nicht davon, die Einstellungen Ihrer Organisation auf der Plattform zu überprüfen und diese Überprüfung zu dokumentieren.

from openai import OpenAI

# Mit der API werden Ihre Daten standardmäßig NICHT für das Training verwendet
# Überprüfen Sie jedoch Ihre Organisationseinstellungen auf platform.openai.com

client = OpenAI()

# Das Endpunkt Responses API respektiert die Aufbewahrungsrichtlinie
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False deaktiviert die Speicherung auf der Seite von OpenAI, falls verfügbar
)

Auf der Nutzerseite wird die Einwilligung nach Zweck, nicht global, verwaltet, was die Struktur hier erklärt: Ein Nutzer kann die konversationelle Unterstützung akzeptieren, während er ablehnt, dass seine Austausche zur Verbesserung des Dienstes verwendet werden. Die Versionsnummer der Richtlinie wird mit der Einwilligung aufgezeichnet – ein entscheidender Detailpunkt an dem Tag, an dem Sie diese Richtlinie aktualisieren. Ohne diese Spur werden Sie nicht wissen, wer mit wem einverstanden war. Schließlich löst die Rücknahme die sofortige Löschung aus, da die Beibehaltung von Daten nach der Rücknahme genau die Situation ist, die eine routinemäßige Prüfung in eine Durchsetzungsmaßnahme verwandelt.

class ConsentManager:
    """Verwaltet die Einwilligung des Nutzers für die KI-Verarbeitung."""

    def __init__(self):
        self.consent_records: dict[str, dict] = {}

    def record_consent(self, user_id: str, purposes: list[str]):
        """Zeichnet die explizite Einwilligung des Nutzers auf."""
        from datetime import datetime
        self.consent_records[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "policy_version": "v2.1",
            "method": "explicit_checkbox",
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Überprüft, ob der Nutzer einer bestimmten Zweck zugestimmt hat."""
        if user_id not in self.consent_records:
            return False
        return purpose in self.consent_records[user_id]["purposes"]

    def withdraw_consent(self, user_id: str):
        """Zieht Einwilligung zurück und löst Datenlöschung aus."""
        if user_id in self.consent_records:
            del self.consent_records[user_id]
            self._delete_data(user_id)

    def _delete_data(self, user_id: str):
        """Löscht alle Daten, die mit dem Nutzer verbunden sind."""
        # Lösche Konversationsverlauf
        # Lösche Protokolle, die personenbezogene Daten enthalten
        # Benachrichtigen Sie Auftragsverarbeiter (OpenAI), falls zutreffend
        print(f"Daten für {user_id} gelöscht")

Reagieren auf Anfragen von betroffenen Personen

Rechte auf Auskunft, Löschung und Datenübertragbarkeit müssen implementiert werden, bevor die erste Anfrage eintrifft, da das einmonatige Reaktionsfenster schnell verschwindet, wenn Sie noch den Code schreiben. Das Recht auf Auskunft verlangt mehr als nur Rohdaten: Sie müssen Zwecke, die Liste der Auftragsverarbeiter und Aufbewahrungsfristen bereitstellen – Informationen, die Sie besser im Voraus konsolidieren sollten.

Das Recht auf Löschung erfordert eine sorgfältige Code-Überprüfung. Die Antwort unterscheidet explizit lokale Daten, die sofort gelöscht werden, von Daten, die an die API gesendet wurden, die unter die Aufbewahrungsrichtlinie des Anbieters fallen. Diese Ehrlichkeit ist zwingend: Das Versprechen einer vollständigen, sofortigen Löschung, während eine Kopie bei einem Auftragsverarbeiter verbleibt, gefährdet Sie mehr als die klare Dokumentation beider Regime.

class DataSubjectRights:
    """Implementiert DSGVO-Rechte für Nutzer."""

    def right_of_access(self, user_id: str) -> dict:
        """Gibt alle beim Nutzer gespeicherten Daten zurück."""
        return {
            "personal_data": self._collect_data(user_id),
            "processing_purposes": ["customer_support", "service_improvement"],
            "subprocessors": ["OpenAI (LLM API)", "PostgreSQL (storage)"],
            "retention_period": "12 Monate nach letzter Aktivität",
            "source": "Direkte Eingabe des Nutzers",
        }

    def right_to_erasure(self, user_id: str) -> dict:
        """Löscht alle Nutzerdaten."""
        # Lösche aus lokaler Datenbank
        deleted_local = self._delete_local(user_id)
        # An OpenAI API gesendete Daten unterliegen
        # ihrer Aufbewahrungsrichtlinie (max. 30 Tage über API)
        return {
            "status": "gelöscht",
            "local_data": "gelöscht",
            "openai_data": "unterliegt 30-tägiger Aufbewahrung",
            "date": datetime.now().isoformat(),
        }

    def right_to_portability(self, user_id: str) -> dict:
        """Exportiert Daten in einem strukturierten Format."""
        data = self._collect_data(user_id)
        return {
            "format": "JSON",
            "data": data,
            "export_date": datetime.now().isoformat(),
        }

    def _collect_data(self, user_id: str) -> dict:
        return {"user_id": user_id, "conversations": [], "profile": {}}

    def _delete_local(self, user_id: str) -> int:
        return 0

Formalisieren Sie die Folgenabschätzung

Für jede KI-Anwendung, die personenbezogene Daten in großem Maßstab verarbeitet, ist eine Datenschutz-Folgenabschätzung (DSFA) zwingend erforderlich. Die Struktur unten zeigt die erwarteten Abschnitte, und das Beispiel illustriert, wie eine abgeschlossene DSFA für einen Kundenservice-Chatbot aussieht.

Zwei Felder ziehen die meiste Aufmerksamkeit einer Aufsichtsbehörde auf sich. Erstens Übertragungen außerhalb der EU: Sobald die Verarbeitung über einen US-Anbieter läuft, müssen Sie den Empfänger, das Land und die herangezogene Sicherung nennen – hier Standardvertragsklauseln (SCC), ergänzt durch die OpenAI-Datenschutzvereinbarung. Zweitens die Risikoanalyse, die spezifisch für das beschriebene System sein muss. Das im Beispiel ausgewählte Risiko ist die undichte Übertragung personenbezogener Daten durch Prompt-Injection, wobei die Minderungsmaßnahmen Anti-Exfiltration-Guardrails und Moderation sind: Alles, was Sie in vorherigen Kapiteln gebaut haben, findet hier seine regulatorische Übersetzung.

@dataclass
class ImpactAssessment:
    """Struktur einer DSFA für ein KI-System."""
    processing_name: str
    description: str
    legal_basis: str
    data_processed: list[str]
    recipients: list[str]
    transfers_outside_eu: list[dict]
    security_measures: list[str]
    risks: list[dict]
    dpo_opinion: str = ""

dpia_chatbot = ImpactAssessment(
    processing_name="Kundenservice-Chatbot mit KI",
    description="Konversationeller Assistent, der GPT-5.6 Sol über OpenAI API verwendet",
    legal_basis="Berechtigtes Interesse (Kundensupport)",
    data_processed=["first_name", "email", "order_history", "chat_messages"],
    recipients=["Support-Team", "OpenAI (API-Auftragsverarbeiter)"],
    transfers_outside_eu=[{
        "recipient": "OpenAI Inc.",
        "country": "Vereinigte Staaten",
        "safeguard": "Standardvertragsklauseln (SCC) + OpenAI DPA",
    }],
    security_measures=[
        "Anonymisierung vor dem Senden an die API",
        "TLS-Verschlüsselung während der Übertragung",
        "Zugriffsprotokolle mit 90-tägiger Aufbewahrung",
        "Recht auf Löschung implementiert",
    ],
    risks=[{
        "description": "Undichte Übertragung personenbezogener Daten durch Prompt-Injection",
        "likelihood": "medium",
        "severity": "high",
        "mitigation": "Anti-Exfiltration-Guardrails + Moderation",
    }],
)

Kernaussagen

• Die DSGVO gilt, sobald ein KI-System Daten europäischer Bewohner verarbeitet
• Datensparsamkeit (Anonymisierung vor dem Senden an die API) ist die erste Reflexion
• Rechte betroffener Personen (Auskunft, Löschung, Datenübertragbarkeit) müssen implementiert werden
• Eine DSFA ist für die Verarbeitung von KI in großem Maßstab zwingend erforderlich
• Übertragungen außerhalb der EU werden dokumentiert durch die OpenAI-DPA und explizite Sicherungen (SCC, Transfer-Folgenabschätzung)