Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Databeskyttelse og GDPR

Lektion 21 af 22 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Databeskyttelse og GDPR
  2. Hvordan OpenAI behandler dine data
  3. Dataminimering
  4. GDPR-kompatibel pipeline
  5. Håndtering af samtykke
  6. Retten til sletning (artikel 17)
  7. GDPR-tjekliste til udviklere
  8. Vigtige pointer

Databeskyttelse og GDPR

Som europæisk udvikler skal du forstå, hvordan data strømmer gennem OpenAI API, og hvilke skridt du skal tage for at overholde GDPR (General Data Protection Regulation). Denne lektion dækker de tekniske aspekter vedrørende overholdelse. Den erstatter ikke rådgivning fra din databeskyttelsesansvarlige (DPO), men den giver dig de kodningspraksisser, der gør deres arbejde muligt – og som, hvis de forsømmes under designfasen, bliver ekstremt dyre at rette op på senere.

Hvordan OpenAI behandler dine data

Via API’et (ikke ChatGPT)

At skelne mellem API-brug og forbrugerbrug er udgangspunktet for enhver diskussion om dette emne. Når du bruger OpenAI API til din applikation, bruges data ikke til at træne modeller: dette er API-politikken, som adskiller sig fra ChatGPT’s, og det er argumentet, du vil bruge til at imødegå den hyppigste indvending i sikkerhedsudvalg. Data opbevares dog i 30 dage for at muliggøre registrering af misbrug og slettes derefter. Du kan forkorte denne opbevaringsperiode: du kan anmode om tidlig sletning via funktionen Zero Data Retention. Ét punkt skal stadig dokumenteres i din konsekvensanalyse – data passerer gennem OpenAI-servere, der primært er placeret i USA, hvilket udgør en overførsel uden for Den Europæiske Union.

# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls

Dataminimering

GDPR kræver, at kun strengt nødvendige data behandles. Anvend dette princip på dine API-kald: i langt de fleste tilfælde har modellen ikke brug for at kende en persons navn, e-mailadresse eller telefonnummer for at opsummere deres forespørgsel eller klassificere dens emne.

Reversibel pseudonymisering imødekommer præcis dette behov. Før afsendelse erstattes hver enkelt personoplysning med en nummereret markør, og mappingen opbevares i hukommelsen på din server. API’et ser kun [EMAIL_1] og [TEL_1]. Ved retur genindsættes markørerne i den genererede tekst, og slutbrugeren modtager et komplet svar, uden at koordinaterne nogensinde har forladt dit system.

import re

def anonymize_before_send(text: str) -> tuple[str, dict]:
    """Anonymizes personal data before sending to the API."""
    replacements = {}
    counter = {"email": 0, "phone": 0, "name": 0}

    # Emails
    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
    )

    # French phone numbers
    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:
    """Restores data after API processing."""
    for key, value in replacements.items():
        text = text.replace(key, value)
    return text

# Usage
from openai import OpenAI
client = OpenAI()

original_text = "Contact Jean Dupont at [email protected] or 06 12 34 56 78"

# Anonymize
anonymous_text, mapping = anonymize_before_send(original_text)
print(f"Sent to API: {anonymous_text}")
# Sent to API: Contact Jean Dupont at [EMAIL_1] or [TEL_1]

# API call with anonymized data
response = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Summarize this message: {anonymous_text}"
)

# Restore
result = restore_data(response.output_text, mapping)
print(f"Final result: {result}")

Se nøje på outputtet fra dette eksempel: „Jean Dupont” er stadig der. Tælleren indeholder en post for name, men intet regulært udtryk udfylder den – detektering af et efternavn kræver genkendelse af navngivne enheder (NER), ikke et tegnmønster. Betragt derfor denne funktion som et fundament, du skal bygge videre på, og ikke som en komplet anonymiseringsløsning.

GDPR-kompatibel pipeline

Minimering alene er ikke nok: reguleringen kræver også, at hver behandlingsoperation hviler på et identificeret juridisk grundlag og registreres. Denne pipeline kombinerer begge krav i fire trin: registrer formål og juridisk grundlag, minimer, kald, genopret. Brugeridentifikatoren gemmes aldrig i klar tekst, men hashes, så registret forbliver brugbart til optælling af operationer uden selv at udgøre en fil med personoplysninger.

from datetime import datetime
import json
import hashlib

class GDPRCompliantPipeline:
    """GDPR-compliant processing pipeline."""

    def __init__(self):
        self.client = OpenAI()
        self.processing_logs = []

    def process(self, text: str, purpose: str,
                legal_basis: str, user_id: str) -> str:
        """Processes text in compliance with GDPR."""

        # 1. Record the legal basis of processing
        processing = {
            "timestamp": datetime.now().isoformat(),
            "user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
            "purpose": purpose,
            "legal_basis": legal_basis,  # consent, legitimate_interest, contract
        }

        # 2. Minimize data
        anonymous_text, mapping = anonymize_before_send(text)

        # 3. API call
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=anonymous_text,
            # Store for the shortest time possible
        )

        processing["tokens_used"] = response.usage.total_tokens
        self.processing_logs.append(processing)

        # 4. Restore and return
        return restore_data(response.output_text, mapping)

    def export_register(self) -> str:
        """Exports the record of processing activities (Article 30 GDPR)."""
        return json.dumps(self.processing_logs, indent=2, ensure_ascii=False)

# Usage
pipeline = GDPRCompliantPipeline()

result = pipeline.process(
    text="Customer Pierre Martin wishes to cancel his subscription.",
    purpose="Cancellation request processing",
    legal_basis="contract",
    user_id="user-456"
)
print(result)
print(pipeline.export_register())

Parameteren legal_basis fortjener opmærksomhed: Behandling af en anmodning om opsigelse falder under opfyldelse af en kontrakt, ikke samtykke. At vælge det forkerte juridiske grundlag er den hyppigste og mest konsekvensrige fejl, da det afgør, hvilke rettigheder en bruger kan udøve i forhold til den pågældende behandling.

Håndtering af samtykke

Når det valgte juridiske grundlag er samtykke, skal det indsamles, dateres, versioneres og frem for alt være tilbagekaldeligt. Manageren nedenfor gemmer samtykke pr. formål – accept af AI-assistance indebærer ikke accept af tekstanalyse – og verificerer denne overensstemmelse før hver behandlingsoperation. Tilbagetrækningsmetoden indeholder en kritisk kommentar: Det er ikke nok at slette samtykkeregistret; du skal også slette de data, der afhæng af det.

class ConsentManager:
    """Manages user consent for AI processing."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Records user consent."""
        self.consents[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "version": "v1.0"
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Checks if the user has consented to a purpose."""
        consent = self.consents.get(user_id)
        if not consent:
            return False
        return purpose in consent["purposes"]

    def withdraw_consent(self, user_id: str):
        """Withdraws consent (right to withdraw)."""
        if user_id in self.consents:
            del self.consents[user_id]
            # Here: also delete associated data

# Usage
consent = ConsentManager()

# User consents to AI processing
consent.record_consent("user-123", ["ai_assistance", "text_analysis"])

# Verify before every processing operation
if consent.verify_consent("user-123", "ai_assistance"):
    # Proceed with processing
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="User question"
    )
else:
    print("Consent required for this processing")

Retten til sletning (artikel 17)

Når en bruger anmoder om sletning af deres data, strækker din forpligtelse sig ud over applikationsdatabasen. Du skal rydde alle steder: lokale data, logs indeholdende personoplysninger – som ofte glemmes – og dokumentere operationen for at kunne retfærdiggøre den. På API-siden er handlingen allerede dækket af opbevaringspolitikken: sendte data forsvinder automatisk efter tredive dage, eller øjeblikkeligt hvis Zero Data Retention er aktiveret.

def exercise_right_to_erasure(user_id: str):
    """Implements the GDPR right to erasure."""

    # 1. Delete local data
    # delete_user_data(user_id)

    # 2. Data sent to the OpenAI API is deleted
    # automatically after 30 days (or immediately
    # with Zero Data Retention enabled)

    # 3. Delete logs containing personal data
    # delete_user_logs(user_id)

    # 4. Document the deletion
    log = {
        "action": "right_to_erasure",
        "user_hash": hashlib.sha256(user_id.encode()).hexdigest()[:12],
        "date": datetime.now().isoformat(),
        "data_deleted": [
            "conversation_history",
            "user_profile",
            "activity_logs"
        ]
    }
    print(json.dumps(log, indent=2, ensure_ascii=False))

exercise_right_to_erasure("user-123")

GDPR-tjekliste til udviklere

  • Identificer det juridiske grundlag for hver behandlingsoperation (samtykke, kontrakt osv.)
  • Minimer data sendt til API’et (anonymisering)
  • Før et register over behandlingsaktiviteter (artikel 30)
  • Implementer retten til indsigt og retten til sletning
  • Dokumenter overførsler uden for EU (OpenAI = US-servere)
  • Aktiver Zero Data Retention, hvis muligt
  • Log aldrig personoplysninger i klar tekst

Vigtige pointer

  • OpenAI API gentræner IKKE sine modeller med dine data
  • Anonymiser personoplysninger før hvert API-kald
  • Før et register over behandlingsaktiviteter i overensstemmelse med artikel 30
  • Implementer GDPR-rettigheder: indsigt, berigtigelse, sletning, dataportabilitet
  • Dataoverførsler uden for EU kræver garantier (standardkontraktbestemmelser)
  • Dokumenter hver beslutning vedrørende databeskyttelse