Datenschutz und DSGVO
Auf dieser Seite
Datenschutz und DSGVO
Als europäischer Entwickler müssen Sie verstehen, wie Daten durch die OpenAI API fließen, und welche Schritte Sie unternehmen müssen, um der DSGVO (Datenschutz-Grundverordnung) zu entsprechen. Diese Lektion behandelt die technischen Aspekte der Compliance. Sie ersetzt keine Beratung durch Ihren Datenschutzbeauftragten (DSB), liefert Ihnen jedoch die Programmierpraktiken, die dessen Arbeit ermöglichen – und die, wenn sie im Design vernachlässigt werden, später extrem kostspielig zu beheben sind.
Wie OpenAI Ihre Daten verarbeitet
Über die API (nicht über ChatGPT)
Die Unterscheidung zwischen API-Nutzung und Verbrauchernutzung ist der Ausgangspunkt für jede Diskussion zu diesem Thema. Wenn Sie die OpenAI API für Ihre Anwendung nutzen, werden Daten nicht zum Trainieren von Modellen verwendet: Dies ist die API-Richtlinie, die sich von der von ChatGPT unterscheidet, und es ist das Argument, das Sie verwenden werden, um die häufigste Einwendung in Sicherheitskomitees zu entkräften. Daten werden jedoch für 30 Tage gespeichert, um Missbrauchserkennung zu ermöglichen, und anschließend gelöscht. Sie können diese Speicherfrist verkürzen: Sie können über die Funktion Zero Data Retention eine vorzeitige Löschung anfordern. Ein Punkt bleibt für Ihre Datenschutz-Folgenabschätzung zu dokumentieren: Daten durchlaufen OpenAI-Server, die sich hauptsächlich in den Vereinigten Staaten befinden, was einen Transfer außerhalb der Europäischen Union darstellt.
# Prüfen Sie die Speicherpolitik Ihrer Organisation
# unter platform.openai.com/settings/organization/data-controls
Datenminimierung
Die DSGVO verlangt die Verarbeitung ausschließlich notwendiger Daten. Wenden Sie dieses Prinzip auf Ihre API-Aufrufe an: In den meisten Fällen benötigt das Modell keinen Namen, eine E-Mail-Adresse oder eine Telefonnummer einer Person, um deren Anfrage zusammenzufassen oder deren Thema zu klassifizieren.
Reversible Pseudonymisierung adressiert genau diesen Bedarf. Vor dem Senden wird jedes Stück personenbezogener Daten durch einen nummerierten Platzhalter ersetzt, und die Zuordnung wird im Arbeitsspeicher auf Ihrem Server gespeichert. Die API sieht nur [EMAIL_1] und [TEL_1]. Nach der Rückgabe werden die Platzhalter im generierten Text wiederhergestellt, und der Endnutzer erhält eine vollständige Antwort, ohne dass Koordinaten jemals Ihr System verlassen.
import re
def anonymize_before_send(text: str) -> tuple[str, dict]:
"""Anonymisiert personenbezogene Daten vor dem Senden an die API."""
replacements = {}
counter = {"email": 0, "phone": 0, "name": 0}
# E-Mails
def replace_email(match):
counter["email"] += 1
key = f"[EMAIL_{counter['email']}]"
replacements[key] = match.group()
return key
text = re.sub(
r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
replace_email, text
)
# Französische Telefonnummern
def replace_phone(match):
counter["phone"] += 1
key = f"[TEL_{counter['phone']}]"
replacements[key] = match.group()
return key
text = re.sub(
r'\b(?:0|\+33)\s*[1-9](?:[\s.-]*\d{2}){4}\b',
replace_phone, text
)
return text, replacements
def restore_data(text: str, replacements: dict) -> str:
"""Wiederherstellt Daten nach der API-Verarbeitung."""
for key, value in replacements.items():
text = text.replace(key, value)
return text
# Nutzung
from openai import OpenAI
client = OpenAI()
original_text = "Kontaktieren Sie Jean Dupont unter [email protected] oder 06 12 34 56 78"
# Anonymisieren
anonymous_text, mapping = anonymize_before_send(original_text)
print(f"An die API gesendet: {anonymous_text}")
# An die API gesendet: Kontaktieren Sie Jean Dupont unter [EMAIL_1] oder [TEL_1]
# API-Aufruf mit anonymisierten Daten
response = client.responses.create(
model="gpt-5.6-terra",
input=f"Fassen Sie diese Nachricht zusammen: {anonymous_text}"
)
# Wiederherstellen
result = restore_data(response.output_text, mapping)
print(f"Endergebnis: {result}")
Schauen Sie sich genau die Ausgabe dieses Beispiels an: “Jean Dupont” ist immer noch vorhanden. Der Zähler enthält einen Eintrag für name, aber kein regulärer Ausdruck füllt ihn – die Erkennung eines Nachnamens erfordert die Named-Entity-Erkennung, nicht ein Zeichenmuster. Betrachten Sie diese Funktion daher als Grundlage, auf der Sie aufbauen, und nicht als vollständige Anonymisierungslösung.
DSGVO-konformer Pipeline
Minimierung allein reicht nicht aus: Die Verordnung verlangt auch, dass jede Verarbeitungsvorgang auf einer identifizierten Rechtsgrundlage beruht und dokumentiert wird. Diese Pipeline kombiniert beide Anforderungen in vier Schritten – Rechtsgrundlage und Zweck dokumentieren, minimieren, aufrufen, wiederherstellen. Der Benutzerkennzeichner wird niemals als Klartext gespeichert, sondern gehasht, sodass das Register für die Zählung von Vorgängen nutzbar bleibt, ohne selbst eine Datei personenbezogener Daten zu bilden.
from datetime import datetime
import json
import hashlib
class GDPRCompliantPipeline:
"""DSGVO-konformer Verarbeitungspipeline."""
def __init__(self):
self.client = OpenAI()
self.processing_logs = []
def process(self, text: str, purpose: str,
legal_basis: str, user_id: str) -> str:
"""Verarbeitet Text in Übereinstimmung mit der DSGVO."""
# 1. Dokumentieren Sie die Rechtsgrundlage der Verarbeitung
processing = {
"timestamp": datetime.now().isoformat(),
"user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
"purpose": purpose,
"legal_basis": legal_basis, # Einwilligung, berechtigtes Interesse, Vertrag
}
# 2. Minimieren Sie Daten
anonymous_text, mapping = anonymize_before_send(text)
# 3. API-Aufruf
response = self.client.responses.create(
model="gpt-5.6-terra",
input=anonymous_text,
# Speichern Sie so kurz wie möglich
)
processing["tokens_used"] = response.usage.total_tokens
self.processing_logs.append(processing)
# 4. Wiederherstellen und zurückgeben
return restore_data(response.output_text, mapping)
def export_register(self) -> str:
"""Exportiert das Verzeichnis der Verarbeitungstätigkeiten (Artikel 30 DSGVO)."""
return json.dumps(self.processing_logs, indent=2, ensure_ascii=False)
# Nutzung
pipeline = GDPRCompliantPipeline()
result = pipeline.process(
text="Der Kunde Pierre Martin möchte sein Abo kündigen.",
purpose="Verarbeitung der Kündigungsanfrage",
legal_basis="vertrag",
user_id="user-456"
)
print(result)
print(pipeline.export_register())
Der Parameter legal_basis verdient Aufmerksamkeit: Die Verarbeitung einer Kündigungsanfrage fällt unter Vertragserfüllung, nicht unter Einwilligung. Die falsche Wahl der Rechtsgrundlage ist der häufigste und folgenschwerste Fehler, da sie die Rechte bestimmt, die ein Benutzer gegenüber dieser Verarbeitung ausüben kann.
Einwilligungsmanagement
Wenn die gewählte Rechtsgrundlage die Einwilligung ist, muss diese gesammelt, datiert, versioniert und vor allem widerrufbar sein. Der Manager unten speichert Einwilligungen nach Zweck – die Annahme von KI-Unterstützung impliziert nicht die Annahme von Textanalyse – und überprüft diese Übereinstimmung vor jeder Verarbeitungsvorgang. Die Widerrufsmethode trägt einen kritischen Kommentar: Das Löschen des Einwilligungsdatums reicht nicht aus; Sie müssen auch die Daten löschen, die davon abhängig waren.
class ConsentManager:
"""Verwaltet die Benutzerzustimmung für KI-Verarbeitung."""
def __init__(self):
self.consents: dict[str, dict] = {}
def record_consent(self, user_id: str, purposes: list[str]):
"""Dokumentiert die Benutzerzustimmung."""
self.consents[user_id] = {
"purposes": purposes,
"date": datetime.now().isoformat(),
"version": "v1.0"
}
def verify_consent(self, user_id: str, purpose: str) -> bool:
"""Überprüft, ob der Benutzer einem Zweck zugestimmt hat."""
consent = self.consents.get(user_id)
if not consent:
return False
return purpose in consent["purposes"]
def withdraw_consent(self, user_id: str):
"""Zieht Zustimmung zurück (Recht auf Widerruf)."""
if user_id in self.consents:
del self.consents[user_id]
# Hier: Auch abhängige Daten löschen
# Nutzung
consent = ConsentManager()
# Benutzer stimmt KI-Verarbeitung zu
consent.record_consent("user-123", ["ai_assistance", "text_analysis"])
# Überprüfen Sie vor jedem Verarbeitungsvorgang
if consent.verify_consent("user-123", "ai_assistance"):
# Verarbeitung fortsetzen
response = client.responses.create(
model="gpt-5.6-terra",
input="Benutzerfrage"
)
else:
print("Für diese Verarbeitung ist Zustimmung erforderlich")
Recht auf Löschung (Artikel 17)
Wenn ein Benutzer die Löschung seiner Daten verlangt, erstreckt sich Ihre Verpflichtung über die Anwendungsdatenbank hinaus. Sie müssen alle Standorte durchsuchen: lokale Daten, Logs mit personenbezogenen Informationen – oft vergessen – und dokumentieren Sie die Operation, um sie zu rechtfertigen. Auf der API-Seite ist die Maßnahme bereits durch die Speicherpolitik abgedeckt: Gesendete Daten verschwinden automatisch nach dreißig Tagen oder sofort, wenn Zero Data Retention aktiviert ist.
def exercise_right_to_erasure(user_id: str):
"""Setzt das DSGVO-Recht auf Löschung um."""
# 1. Lokale Daten löschen
# delete_user_data(user_id)
# 2. Daten, die an die OpenAI API gesendet wurden, werden gelöscht
# automatisch nach 30 Tagen (oder sofort
# mit aktivierter Zero Data Retention)
# 3. Logs mit personenbezogenen Daten löschen
# delete_user_logs(user_id)
# 4. Löschung dokumentieren
log = {
"action": "right_to_erasure",
"user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
"date": datetime.now().isoformat(),
"data_deleted": [
"Gesprächsgeschichte",
"Benutzerprofil",
"Aktivitätsprotokolle"
]
}
print(json.dumps(log, indent=2, ensure_ascii=False))
exercise_right_to_erasure("user-123")
DSGVO-Checkliste für Entwickler
- Identifizieren Sie die Rechtsgrundlage für jeden Verarbeitungsvorgang (Einwilligung, Vertrag usw.)
- Minimieren Sie die an die API gesendeten Daten (Anonymisierung)
- Führen Sie ein Verzeichnis der Verarbeitungstätigkeiten (Artikel 30)
- Implementieren Sie das Recht auf Auskunft und das Recht auf Löschung
- Dokumentieren Sie Transfers außerhalb der EU (OpenAI = US-Server)
- Aktivieren Sie Zero Data Retention, wenn möglich
- Loggen Sie niemals personenbezogene Daten als Klartext
Kernaussagen
- Die OpenAI API verwendet Ihre Daten nicht zum Nachtrainieren ihrer Modelle
- Anonymisieren Sie personenbezogene Daten vor jedem API-Aufruf
- Führen Sie ein Verzeichnis der Verarbeitungstätigkeiten gemäß Artikel 30
- Implementieren Sie DSGVO-Rechte: Auskunft, Berichtigung, Löschung, Datenübertragbarkeit
- Datenübermittlungen außerhalb der EU erfordern Schutzmaßnahmen (Standardvertragsklauseln)
- Dokumentieren Sie jede Entscheidung zum Datenschutz