Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

GDPR en gegevensbescherming met OpenAI

Les 13 van 14 Bijgewerkt op 28 juli 2026 Gevorderd
Op deze pagina
  1. AI en de AVG: Een niet-onderhandelbaar kader
  2. Zeven principes, vertaald voor een LLM-systeem
  3. Minimalisatie: De maatregel die de meeste problemen oplost
  4. Configureer de service en verzamel toestemming
  5. Reageren op verzoeken van betrokkenen
  6. Formaliseer de effectbeoordeling
  7. Belangrijkste punten

AI en de AVG: Een niet-onderhandelbaar kader

De Algemene Verordening Gegevensbescherming (AVG) is van toepassing op elke applicatie die persoonsgegevens van Europese ingezetenen verwerkt, inclusief applicaties die zijn gebouwd op grote taalmodellen (LLM’s). Er zijn geen uitzonderingen voor kunstmatige intelligentie. Dit zorgt vaak voor verwarring bij technische teams: zij zoeken naar AI-specifieke regelgeving, terwijl de toepasselijke tekst al jaren bestaat en niet is gewijzigd. In 2026 richten handhavingsacties zich steeds vaker op AI-systemen. Het gebruik van de API’s van OpenAI in deze context draait minder om het leren van nieuwe wetgeving en meer om het vertalen van bekende juridische vereisten naar een nieuwe architectuur.

Zeven principes, vertaald voor een LLM-systeem

De AVG rust op zeven kernprincipes, die elk een specifieke betekenis krijgen wanneer een taalmodel deelneemt aan de verwerkingsketen.

Principe AI-toepassing
Rechtmatigheid Rechtsgrond voor het verzenden van gegevens naar de API (toestemming, gerechtvaardigd belang, overeenkomst)
Gegevensminimalisatie Verzend alleen gegevens die strikt noodzakelijk zijn voor het model
Doelbinding Verzonden gegevens mogen alleen dienen voor het verklaarde doel
Juistheid Modeluitvoer kan onjuist zijn—informeer de gebruiker
Opslagbeperking Controleer het bewaarbeleid van OpenAI en wis gegevens aan de clientzijde
Integriteit en vertrouwelijkheid Versleuteling tijdens transport, toegangscontrole, logaudit
Verantwoordingsplicht Documenteer keuzes en toon naleving aan

Twee principes verrassen teams regelmatig. Ten eerste juistheid: dit maakt hallucinaties van een kwaliteitskwestie tot een regelgevingskwestie. Wanneer een model onjuiste informatie genereert over een geïdentificeerde persoon, heeft die persoon het recht op rectificatie. Ten tweede verantwoordingsplicht: compliant zijn is niet genoeg; u moet het kunnen bewijzen. Dit transformeert documentatie van een best practice naar een wettelijke verplichting.

Minimalisatie: De maatregel die de meeste problemen oplost

Van alle beschikbare maatregelen biedt pseudonimisering voordat u gegevens verzendt de beste balans tussen inspanning en risicoreductie. De logica is eenvoudig: wat uw systeem nooit verlaat, kan niet lekken naar een subverwerker, roept geen vragen op tijdens overdrachten buiten de EU en compliceert verzoeken tot verwijdering niet.

Het onderstaande mechanisme vervangt elk stukje identificerende data door een stabiele token, houdt de koppeling lokaal in het geheugen en herstelt de originele waarden in het antwoord. De eindgebruiker ziet “de heer Dupont”, het model ziet alleen “[PERSON_1]” en de servicefunctie blijft volledig intact; de assistent kan nog steeds zijn antwoord opstellen omdat hij de achternaam nooit nodig had.

De opmerking bij namen is niet decoratief: het patroon vangt alleen vormen die worden voorafgegaan door een titel. Een kale naam glipt erdoorheen. In productie neemt een Named Entity Recognition (NER)-model het over, en het expliciet opnemen van deze waarschuwing in de code is beter dan vals vertrouwen.

import re

class DataMinimizer:
    """Anonimiseert persoonsgegevens voordat ze naar de API worden verzonden."""

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

    def anonymize(self, text: str) -> str:
        """Vervangt persoonsgegevens door placeholders."""
        # E-mailadressen
        text = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._replace(m.group(), "EMAIL"),
            text,
        )
        # Franse telefoonnummers
        text = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._replace(m.group(), "PHONE"),
            text,
        )
        # Namen (vereenvoudigd patroon—gebruik NER in productie)
        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:
        """Herstelt originele gegevens in het antwoord."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            text = text.replace(placeholder, original)
        return text

# Gebruik
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."

# Na modelantwoord
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}")

Configureer de service en verzamel toestemming

Aan de kant van de provider geldt deze regel: gegevens die via de API worden verzonden, worden standaard niet gebruikt voor training, in tegenstelling tot wat velen aannemen door analogie met consumenteninterfaces. Dit ontslaat u niet van de plicht om de instellingen van uw organisatie op het platform te controleren en die verificatie te documenteren.

from openai import OpenAI

# Met de API worden uw gegevens standaard NIET gebruikt voor training
# Maar verifieer uw organisatie-instellingen op platform.openai.com

client = OpenAI()

# Het Responses API-endpoint respecteert het bewaarbeleid
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Hello"}],
    # store=False schakelt opslag aan de kant van OpenAI uit indien beschikbaar
)

Aan de kant van de gebruiker wordt toestemming beheerd per doel, niet globaal, wat de structuur hier verklaart: een gebruiker kan conversationele assistentie accepteren terwijl hij weigert dat zijn uitwisselingen worden gebruikt om de service te verbeteren. De beleidsversie wordt samen met de toestemming vastgelegd; een cruciaal detail voor het moment dat u dat beleid update. Zonder dit spoor weet u niet wie waar mee akkoord is gegaan. Tot slot leidt intrekking tot onmiddellijke verwijdering, omdat het bewaren van gegevens na intrekking precies het scenario is dat een routine-audit verandert in een handhavingsactie.

class ConsentManager:
    """Beheert gebruikerstoestemming voor AI-verwerking."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Legt expliciete gebruikerstoestemming vast."""
        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:
        """Controleert of de gebruiker heeft ingestemd met een specifiek doel."""
        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):
        """Trekt toestemming in en start gegevensverwijdering."""
        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):
        """Verwijdert alle gegevens die aan de gebruiker zijn gekoppeld."""
        # Verwijder conversatiegeschiedenis
        # Verwijder logs met persoonsgegevens
        # Informeer subverwerkers (OpenAI) indien van toepassing
        print(f"Data deleted for {user_id}")

Reageren op verzoeken van betrokkenen

Rechten op inzage, verwijdering en overdraagbaarheid moeten zijn geïmplementeerd voordat het eerste verzoek binnenkomt, omdat de responstermijn van één maand snel verdwijnt wanneer u nog code aan het schrijven bent. Het recht op inzage vereist meer dan ruwe data: u moet doelen, de lijst van subverwerkers en bewaartermijnen verstrekken; informatie die u beter vooraf kunt consolideren.

Het recht op verwijdering vereist een zorgvuldige code-review. Het antwoord maakt expliciet onderscheid tussen lokale gegevens, die onmiddellijk worden verwijderd, en gegevens die naar de API zijn verzonden, die onder het bewaarbeleid van de provider vallen. Deze eerlijkheid is verplicht: het beloven van totale, onmiddellijke verwijdering terwijl er een kopie bij een subverwerker blijft, stelt u meer bloot dan het duidelijk documenteren van beide regimes.

class DataSubjectRights:
    """Implementeert AVG-rechten voor gebruikers."""

    def right_of_access(self, user_id: str) -> dict:
        """Geeft alle gegevens over de gebruiker terug."""
        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:
        """Verwijdert alle gebruikersgegevens."""
        # Verwijder uit lokale database
        deleted_local = self._delete_local(user_id)
        # Gegevens verzonden naar de OpenAI API vallen onder
        # hun bewaarbeleid (maximaal 30 dagen 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:
        """Exporteert gegevens in een gestructureerd formaat."""
        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

Formaliseer de effectbeoordeling

Voor elke AI-toepassing die persoonsgegevens op grote schaal verwerkt, is een Gegevensbeschermingseffectbeoordeling (GEB) verplicht. De onderstaande structuur toont de verwachte secties en het voorbeeld illustreert hoe een ingevulde GEB eruitziet voor een klantenservice-chatbot.

Twee velden trekken de meeste aandacht van een toezichthouder. Ten eerste overdrachten buiten de EU: wanneer verwerking via een Amerikaanse provider loopt, moet u de ontvanger, het land en de ingeroepen waarborg noemen; hier de Standaardcontractbepalingen (SCB’s) aangevuld met de Data Processing Agreement van OpenAI. Ten tweede de risicoanalyse, die specifiek moet zijn voor het beschreven systeem. Het in het voorbeeld geselecteerde risico is lekken van persoonsgegevens via prompt-injectie, met als mitigatiemaatregelen anti-exfiltratie-beveiligingen en moderatie: alles wat u in vorige hoofdstukken heeft gebouwd, vindt hier zijn regelgevende vertaling.

@dataclass
class ImpactAssessment:
    """Structuur van een GEB voor een AI-systeem."""
    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",
    }],
)

Belangrijkste punten

  • De AVG is van toepassing zodra een AI-systeem gegevens van Europese ingezetenen verwerkt
  • Gegevensminimalisatie (anonimisering voordat verzending naar de API plaatsvindt) is de eerste reflex
  • Rechten van betrokkenen (inzage, verwijdering, overdraagbaarheid) moeten zijn geïmplementeerd
  • Een GEB is verplicht voor AI-verwerking op grote schaal
  • Overdrachten buiten de EU worden gedocumenteerd via de DPA van OpenAI en expliciete waarborgen (SCB’s, beoordeling van overdrachtseffecten)