GDPR og databeskyttelse med OpenAI
På denne side
AI og GDPR: En ufravigelig ramme
Den generelle forordning om databeskyttelse (GDPR) gælder for enhver applikation, der behandler personoplysninger om europæiske borgere – herunder applikationer bygget på store sprogmodeller (LLM’er). Der findes ingen undtagelser for kunstig intelligens. Dette forvirrer ofte tekniske teams: De leder efter AI-specifikke regler, selvom den gældende lovgivning har eksisteret i årevis og ikke er ændret. I 2026 målretter håndhævelsesindsatsen i stigende grad AI-systemer. At bruge OpenAI’s API’er i denne sammenhæng handler mindre om at lære ny lovgivning og mere om at oversætte kendte juridiske krav til en ny arkitektur.
Syv principper, oversat til et LLM-system
GDPR hviler på syv kerneprincipper, som hver især får en specifik betydning, når en sprogmodel indgår i behandlingskæden.
| Princip | AI-anvendelse |
|---|---|
| Lovlighed | Retsgrundlag for at sende data til API'et (samtykke, berettiget interesse, kontrakt) |
| Dataminimering | Send kun data, der er strengt nødvendige for modellen |
| Formålsbegrænsning | Sendte data må kun tjene det erklærede formål |
| Rigtighed | Modeloutput kan være unøjagtige – informér brugeren |
| Opbevaringsbegrænsning | Tjek OpenAI's opbevaringspolitik og slet på klientsiden |
| Sikkerhed | Kryptering under overførsel, adgangskontrol, logrevision |
| Ansvarlighed | Dokumentér valg og vær i stand til at demonstrere overholdelse |
To principper fanger ofte teams på det forkerte ben. For det første rigtighed: Dette gør hallucinationer fra et kvalitetsspørgsmål til et regulatorisk problem. Når en model genererer falske oplysninger om en identificeret person, har denne person ret til berigtigelse. For det andet ansvarlighed: Det er ikke nok at være compliant – du skal kunne bevise det. Dette transformerer dokumentation fra en bedste praksis til en juridisk forpligtelse.
Minimering: Foranstaltningen, der løser de fleste problemer
Af alle tilgængelige foranstaltninger tilbyder pseudonymisering før afsendelse af data den bedste balance mellem indsats og risikoreduktion. Logikken er enkel: Det, der aldrig forlader dit system, kan ikke lække til en underbehandler, kan ikke rejse spørgsmål ved overførsler uden for EU og vil ikke komplicere sletningsanmodninger.
Mekanismen nedenfor erstatter hver enkelt identificerende datapost med et stabilt token, gemmer mappingen i lokal hukommelse og gendanner originale værdier i svaret. Slutbrugeren ser „Hr. Dupont”, modellen ser kun „[PERSON_1]”, og servicefunktionen forbliver fuldt intakt – assistenten kan stadig udarbejde sit svar, fordi den aldrig havde brug for det faktiske efternavn.
Kommentaren om navne er ikke dekorativ: Mønsteret fanger kun former, der er foregået af en titel. Et blot navn vil slippe igennem. I produktion overtager en model til genkendelse af navngivne enheder (NER), og det er bedre eksplicit at have denne advarsel i koden end at have en falsk tryghed.
import re
class DataMinimizer:
"""Anonymizes personal data before sending to the API."""
def __init__(self):
self.mappings: dict[str, str] = {}
self.counter = 0
def anonymize(self, text: str) -> str:
"""Replaces personal data with placeholders."""
# Emails
text = re.sub(
r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
lambda m: self._replace(m.group(), "EMAIL"),
text,
)
# French phone numbers
text = re.sub(
r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
lambda m: self._replace(m.group(), "PHONE"),
text,
)
# Names (simplified pattern—use NER in production)
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:
"""Restores original data in the response."""
reverse = {v: k for k, v in self.mappings.items()}
for placeholder, original in reverse.items():
text = text.replace(placeholder, original)
return text
# Usage
minimizer = DataMinimizer()
original_message = "Mr. Dupont ([email protected], 06 12 34 56 78) requests a refund."
anonymized_message = minimizer.anonymize(original_message)
print(f"Sent to API: {anonymized_message}")
# "[PERSON_1] ([EMAIL_1], [PHONE_1]) requests a refund."
# After model response
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"Final response: {final_response}")
Konfigurér tjenesten og indhent samtykke
På udbydersiden skal du kende denne regel: Data, der sendes via API’et, bruges som standard ikke til træning, i modsætning til hvad mange antager ved analogi med forbrugergrænseflader. Dette fritager dig dog ikke for at tjekke din organisations indstillinger på platformen og dokumentere denne verifikation.
from openai import OpenAI
# With the API, your data is NOT used for training by default
# But verify your organization settings on platform.openai.com
client = OpenAI()
# The Responses API endpoint respects the retention policy
response = client.chat.completions.create(
model="gpt-5.6-sol",
messages=[{"role": "user", "content": "Hello"}],
# store=False disables storage on OpenAI's side if available
)
På brugersiden administreres samtykke efter formål, ikke globalt, hvilket forklarer strukturen her: En bruger kan acceptere samtaleassistance, men nægte at få sine udvekslinger brugt til at forbedre tjenesten. Politikversionen registreres sammen med samtykket – en kritisk detalje den dag, du opdaterer denne politik. Uden denne sporbarhed vil du ikke vide, hvem der har accepteret hvad. Endelig udløser tilbagetrækning øjeblikkelig sletning, fordi opbevaring af data efter tilbagetrækning er præcis det scenarie, der vender en rutinemæssig revision til en håndhævelsessag.
class ConsentManager:
"""Manages user consent for AI processing."""
def __init__(self):
self.consent_records: dict[str, dict] = {}
def record_consent(self, user_id: str, purposes: list[str]):
"""Records explicit user consent."""
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:
"""Checks if the user has consented to a specific purpose."""
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):
"""Withdraws consent and triggers data deletion."""
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):
"""Deletes all data associated with the user."""
# Delete conversation history
# Delete logs containing personal data
# Notify subprocessors (OpenAI) if applicable
print(f"Data deleted for {user_id}")
Besvarelse af anmodninger fra registrerede
Retten til indsigt, sletning og dataportabilitet skal implementeres, før den første anmodning arrives, fordi fristen på én måned forsvinder hurtigt, når du stadig skriver koden. Retten til indsigt kræver mere end rå data: Du skal levere formål, listen over underbehandlere og opbevaringsperioder – oplysninger, som du hellere må konsolidere på forhånd.
Retten til sletning kræver omhyggelig kodegennemgang. Svaret skelner eksplicit mellem lokale data, der slettes øjeblikkeligt, og data sendt til API’et, som falder ind under udbyderens opbevaringspolitik. Denne ærlighed er obligatorisk: At love total, øjeblikkelig sletning, mens en kopi forbliver hos en underbehandler, eksponerer dig mere end klart at dokumentere begge regimer.
class DataSubjectRights:
"""Implements GDPR rights for users."""
def right_of_access(self, user_id: str) -> dict:
"""Returns all data held on the user."""
return {
"personal_data": self._collect_data(user_id),
"processing_purposes": ["customer_support", "service_improvement"],
"subprocessors": ["OpenAI (LLM API)", "PostgreSQL (storage)"],
"retention_period": "12 months after last activity",
"source": "Direct user input",
}
def right_to_erasure(self, user_id: str) -> dict:
"""Deletes all user data."""
# Delete from local database
deleted_local = self._delete_local(user_id)
# Data sent to OpenAI API is subject
# to their retention policy (max 30 days via API)
return {
"status": "deleted",
"local_data": "deleted",
"openai_data": "subject to 30-day retention",
"date": datetime.now().isoformat(),
}
def right_to_portability(self, user_id: str) -> dict:
"""Exports data in a structured 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
Formalisér konsekvensanalysen
For enhver AI-applikation, der behandler personoplysninger i stort omfang, er en konsekvensanalyse for databeskyttelse (DPIA) obligatorisk. Strukturen nedenfor viser de forventede afsnit, og eksemplet illustrerer, hvordan en udfyldt DPIA ser ud for en chatbot til kundeservice.
To felter trækker mest opmærksomhed fra en tilsynsmyndighed. For det første overførsler uden for EU: Når behandling går gennem en amerikansk udbyder, skal du navngive modtageren, landet og den påberåbte garanti – her Standardkontraktbestemmelser (SCC’er) suppleret med OpenAI’s databehandlingsaftale. For det andet risikoanalysen, som skal være specifik for det beskrevne system. Risikoen valgt i eksemplet er lækage af personoplysninger via prompt-injection, hvor afbødningsforanstaltningerne er anti-exfiltration-værn og moderation: Alt det, du har bygget i tidligere kapitler, finder sin regulatoriske oversættelse her.
@dataclass
class ImpactAssessment:
"""Structure of a DPIA for an AI 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="Customer Service Chatbot with AI",
description="Conversational assistant using GPT-5.6 Sol via OpenAI API",
legal_basis="Legitimate interest (customer support)",
data_processed=["first_name", "email", "order_history", "chat_messages"],
recipients=["Support team", "OpenAI (API subprocessor)"],
transfers_outside_eu=[{
"recipient": "OpenAI Inc.",
"country": "United States",
"safeguard": "Standard Contractual Clauses (SCCs) + OpenAI DPA",
}],
security_measures=[
"Anonymization before sending to API",
"TLS encryption in transit",
"Access logs with 90-day retention",
"Right to erasure implemented",
],
risks=[{
"description": "Personal data leakage via prompt injection",
"likelihood": "medium",
"severity": "high",
"mitigation": "Anti-exfiltration guardrails + moderation",
}],
)
Vigtige pointer
- GDPR gælder, så snart et AI-system behandler data om europæiske borgere
- Dataminimering (anonymisering før afsendelse til API’et) er den første refleks
- Rettigheder for registrerede (indsigt, sletning, portabilitet) skal implementeres
- En DPIA er obligatorisk for AI-behandling i stort omfang
- Overførsler uden for EU dokumenteres via OpenAI’s DPA og eksplicitte garantier (SCC’er, vurdering af overførselskonsekvenser)