Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Privacy van gegevens en de AVG

Les 21 van 22 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Privacy van gegevens en de AVG
  2. Hoe OpenAI uw gegevens verwerkt
  3. Dataminimalisatie
  4. AVG-conforme pipeline
  5. Toestemmingsbeheer
  6. Recht op wissing (Artikel 17)
  7. AVG-checklist voor ontwikkelaars
  8. Belangrijkste punten

Privacy van gegevens en de AVG

Als Europese ontwikkelaar moet u begrijpen hoe gegevens door de OpenAI API stromen en welke stappen u moet nemen om te voldoen aan de AVG (Algemene Verordening Gegevensbescherming). Deze les behandelt de technische aspecten van naleving. Het vervangt geen advies van uw Functionaris voor Gegevensbescherming (FG), maar het biedt u de codeerpraktijken die hun werk mogelijk maken. Als u deze tijdens het ontwerp verwaarloost, worden ze later extreem kostbaar om op te lossen.

Hoe OpenAI uw gegevens verwerkt

Via de API (niet ChatGPT)

Het onderscheid maken tussen API-gebruik en consumentengebruik is het startpunt voor elke discussie over dit onderwerp. Wanneer u de OpenAI API voor uw applicatie gebruikt, worden gegevens niet gebruikt om modellen te trainen: dit is het API-beleid, dat verschilt van dat van ChatGPT, en het is het argument dat u zult gebruiken om het meest voorkomende bezwaar in beveiligingscomités aan te pakken. Gegevens worden echter 30 dagen bewaard om misbruikdetectie mogelijk te maken, waarna ze worden verwijderd. U kunt deze bewaartermijn verkorten: u kunt vroegtijdige verwijdering aanvragen via de functie Zero Data Retention. Eén punt blijft documentatie vereisen in uw effectbeoordeling: gegevens reizen via OpenAI-servers, die zich voornamelijk in de Verenigde Staten bevinden, wat neerkomt op een doorgifte buiten de Europese Unie.

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

Dataminimalisatie

De AVG vereist dat alleen strikt noodzakelijke gegevens worden verwerkt. Pas dit principe toe op uw API-aanroepen: in de overgrote meerderheid van de gevallen hoeft het model de naam, het e-mailadres of het telefoonnummer van een persoon niet te kennen om hun verzoek samen te vatten of het onderwerp te classificeren.

Reversibele pseudonimisering speelt precies in op deze behoefte. Voor het verzenden wordt elk stukje persoonsgegevens vervangen door een genummerde marker, en de mapping wordt in het geheugen op uw server bewaard. De API ziet alleen [EMAIL_1] en [TEL_1]. Bij terugkeer worden de markers hersteld in de gegenereerde tekst, en de eindgebruiker ontvangt een compleet antwoord zonder dat coördinaten ooit uw systeem hebben verlaten.

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}")

Kijk goed naar de uitvoer van dit voorbeeld: “Jean Dupont” staat er nog steeds. De teller bevat een entry voor name, maar geen reguliere expressie vult deze in; het detecteren van een achternaam vereist named entity recognition, geen tekenpatroon. Beschouw deze functie daarom als een fundament om op voort te bouwen, niet als een complete anonimiseringsoplossing.

AVG-conforme pipeline

Minimalisatie alleen is niet genoeg: de verordening vereist ook dat elke verwerking rust op een geïdentificeerde rechtsgrondslag en wordt geregistreerd. Deze pipeline combineert beide vereisten in vier stappen: leg het doel en de rechtsgrondslag vast, minimaliseer, roep aan, herstel. De gebruikersidentificatie wordt nooit in platte tekst opgeslagen, maar gehasht, zodat het register bruikbaar blijft voor tellingen zonder zelf een bestand met persoonsgegevens te vormen.

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())

De parameter legal_basis verdient aandacht: het verwerken van een opzegverzoek valt onder de uitvoering van een overeenkomst, niet onder toestemming. Het kiezen van de verkeerde rechtsgrondslag is de meest voorkomende en ingrijpende fout, omdat deze bepaalt welke rechten een gebruiker kan uitoefenen op die verwerking.

Toestemmingsbeheer

Wanneer de gekozen rechtsgrondslag toestemming is, moet deze worden verzameld, gedateerd, geversioneerd en bovenal herroepbaar zijn. De onderstaande manager slaat toestemming per doel op; het accepteren van AI-assistentie impliceert niet de acceptatie van tekstanalyse, en verifieert deze match voor elke verwerking. De methode voor intrekking bevat een kritieke opmerking: het verwijderen van het toestemmingsrecord is niet genoeg; u moet ook de gegevens verwijderen die ervan afhingen.

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")

Recht op wissing (Artikel 17)

Wanneer een gebruiker verzoekt om wissing van zijn gegevens, strekt uw verplichting zich verder uit dan de applicatiedatabase. U moet alle locaties doorlopen: lokale gegevens, logs die persoonsgegevens bevatten (vaak vergeten), en de operatie documenteren om deze te rechtvaardigen. Aan de API-kant is de actie al gedekt door het bewaarbeleid: verzonden gegevens verdwijnen automatisch na dertig dagen, of onmiddellijk als Zero Data Retention is ingeschakeld.

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")

AVG-checklist voor ontwikkelaars

  • Identificeer de rechtsgrondslag voor elke verwerking (toestemming, overeenkomst, enz.)
  • Minimaliseer gegevens die naar de API worden verzonden (anonimisering)
  • Houd een register van verwerkingsactiviteiten bij (Artikel 30)
  • Implementeer het recht op inzage en het recht op wissing
  • Documenteer doorgiften buiten de EU (OpenAI = servers in de VS)
  • Schakel Zero Data Retention in indien mogelijk
  • Log nooit persoonsgegevens in platte tekst

Belangrijkste punten

  • De OpenAI API hertraint zijn modellen NIET met uw gegevens
  • Anonimiseer persoonsgegevens voor elke API-aanroep
  • Houd een register van verwerkingsactiviteiten bij dat conform Artikel 30 is
  • Implementeer AVG-rechten: inzage, rectificatie, wissing, overdraagbaarheid
  • Gegevensoverdrachten buiten de EU vereisen waarborgen (standaardcontractbepalingen)
  • Documenteer elke beslissing met betrekking tot gegevensbescherming