RGPD et protection des données avec OpenAI

L’IA et le RGPD : un cadre incontournable

Le Règlement Général sur la Protection des Données s’applique à toute application qui traite des données personnelles de résidents européens — y compris les applications basées sur des LLM. Aucune exception n’a été prévue pour l’intelligence artificielle, et c’est précisément ce qui déroute les équipes techniques : elles cherchent une réglementation IA spécifique alors que le texte applicable existe depuis des années et n’a pas changé. En 2026, les sanctions pour non-conformité touchent de plus en plus les systèmes IA. Utiliser les APIs OpenAI dans ce cadre suppose donc moins d’apprendre un droit nouveau que de traduire un droit connu dans une architecture qui, elle, est inédite.

Sept principes, traduits pour un système LLM

Le RGPD repose sur sept principes fondamentaux dont chacun prend un sens particulier lorsqu’un modèle de langage entre dans la chaîne de traitement.

Deux de ces principes surprennent régulièrement les équipes. Celui d’exactitude, d’abord, parce qu’il fait des hallucinations un sujet réglementaire et non plus seulement un défaut de qualité : lorsqu’un modèle produit une information fausse au sujet d’une personne identifiée, cette personne dispose d’un droit de rectification. Celui de responsabilité, ensuite, parce qu’il ne suffit pas d’être conforme, il faut pouvoir le démontrer — ce qui transforme la documentation en obligation plutôt qu’en bonne pratique.

Minimiser : la mesure qui règle le plus de problèmes

De toutes les mesures possibles, la pseudonymisation avant envoi est celle qui produit le meilleur rapport entre effort et réduction de risque. Le raisonnement est simple : ce qui ne sort pas de votre système ne peut ni fuiter chez le sous-traitant, ni poser question lors du transfert hors UE, ni compliquer une demande d’effacement.

Le mécanisme ci-dessous remplace chaque donnée identifiante par un jeton stable, conserve la correspondance en mémoire locale, et restaure les valeurs d’origine dans la réponse. L’utilisateur final voit « M. Dupont », le modèle n’a vu que « [PERSONNE_1] », et la fonction du service est intégralement préservée — l’assistant peut toujours rédiger sa réponse, puisqu’il n’avait aucun besoin du vrai patronyme pour cela.

Le commentaire laissé sur les noms n’est pas une coquetterie : le motif retenu ne capture que les formes précédées d’une civilité. Un nom nu passera au travers. En production, un modèle de reconnaissance d’entités nommées prend le relais, et la présence explicite de cet avertissement dans le code vaut mieux qu’une fausse confiance.

import re

class MinimiseurDonnees:
    """Anonymise les données personnelles avant envoi à l'API."""

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

    def anonymiser(self, texte: str) -> str:
        """Remplace les données personnelles par des placeholders."""
        # Emails
        texte = re.sub(
            r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
            lambda m: self._remplacer(m.group(), "EMAIL"),
            texte,
        )
        # Téléphones français
        texte = re.sub(
            r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
            lambda m: self._remplacer(m.group(), "TEL"),
            texte,
        )
        # Noms (pattern simplifié — en production, utilisez un NER)
        texte = re.sub(
            r"\b(M\.|Mme|Dr)\s+[A-Z][a-zéèêë]+\s+[A-Z][a-zéèêë]+\b",
            lambda m: self._remplacer(m.group(), "PERSONNE"),
            texte,
        )
        # IBAN
        texte = 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._remplacer(m.group(), "IBAN"),
            texte,
        )
        return texte

    def _remplacer(self, valeur: str, type_: str) -> str:
        if valeur not in self.mappings:
            self.compteur += 1
            self.mappings[valeur] = f"[{type_}_{self.compteur}]"
        return self.mappings[valeur]

    def desanonymiser(self, texte: str) -> str:
        """Restaure les données originales dans la réponse."""
        reverse = {v: k for k, v in self.mappings.items()}
        for placeholder, original in reverse.items():
            texte = texte.replace(placeholder, original)
        return texte

# Utilisation
minimiseur = MinimiseurDonnees()

message_original = "M. Dupont ([email protected], 06 12 34 56 78) demande un remboursement."
message_anonymise = minimiseur.anonymiser(message_original)
print(f"Envoyé à l'API : {message_anonymise}")
# "[PERSONNE_1] ([EMAIL_1], [TEL_1]) demande un remboursement."

# Après réponse du modèle
reponse_modele = "Le dossier de [PERSONNE_1] a été traité. Un email a été envoyé à [EMAIL_1]."
reponse_finale = minimiseur.desanonymiser(reponse_modele)
print(f"Réponse finale : {reponse_finale}")

Configurer le service et recueillir le consentement

Côté fournisseur, la règle à connaître est que les données transmises par l’API ne sont pas utilisées pour l’entraînement par défaut, contrairement à ce que beaucoup supposent par analogie avec les interfaces grand public. Cela ne vous dispense pas de vérifier les réglages de votre organisation sur la plateforme, ni de documenter cette vérification.

from openai import OpenAI

# Avec l'API, vos données ne sont PAS utilisées pour l'entraînement par défaut
# Mais vérifiez votre organisation settings sur platform.openai.com

client = OpenAI()

# L'endpoint Responses API respecte la politique de rétention
response = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[{"role": "user", "content": "Bonjour"}],
    # store=False désactive le stockage côté OpenAI si disponible
)

Côté utilisateur, le consentement se gère par finalité et non globalement, ce qui explique la structure retenue : un utilisateur peut accepter l’assistance conversationnelle tout en refusant que ses échanges servent à améliorer le service. La version de la politique est enregistrée avec le consentement, détail décisif le jour où vous modifierez cette politique — sans cette trace, vous ne saurez plus qui a accepté quoi. Le retrait, enfin, déclenche immédiatement la suppression, car conserver des données après un retrait est exactement le cas de figure qui transforme un contrôle de routine en sanction.

class GestionConsentement:
    """Gère le consentement utilisateur pour le traitement IA."""

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

    def enregistrer_consentement(self, user_id: str, finalites: list[str]):
        """Enregistre le consentement explicite de l'utilisateur."""
        from datetime import datetime
        self.consentements[user_id] = {
            "finalites": finalites,
            "date": datetime.now().isoformat(),
            "version_politique": "v2.1",
            "moyen": "checkbox_explicite",
        }

    def verifier_consentement(self, user_id: str, finalite: str) -> bool:
        """Vérifie si l'utilisateur a consenti à une finalité spécifique."""
        if user_id not in self.consentements:
            return False
        return finalite in self.consentements[user_id]["finalites"]

    def retirer_consentement(self, user_id: str):
        """Retire le consentement et déclenche la suppression des données."""
        if user_id in self.consentements:
            del self.consentements[user_id]
            self._supprimer_donnees(user_id)

    def _supprimer_donnees(self, user_id: str):
        """Supprime toutes les données associées à l'utilisateur."""
        # Supprimer l'historique de conversation
        # Supprimer les logs contenant des données personnelles
        # Notifier les sous-traitants (OpenAI) si applicable
        print(f"Données supprimées pour {user_id}")

Répondre aux demandes des personnes

Les droits d’accès, d’effacement et de portabilité doivent être implémentés avant la première demande, parce que le délai de réponse d’un mois s’écoule vite quand il faut d’abord écrire le code. Le droit d’accès exige davantage que les données brutes : il faut restituer les finalités, la liste des sous-traitants et la durée de conservation, informations qu’il vaut mieux avoir consolidées à l’avance.

Le droit d’effacement demande une lecture attentive du code. La réponse distingue explicitement les données locales, supprimées immédiatement, et celles transmises à l’API, soumises à la politique de rétention du fournisseur. Cette honnêteté est une obligation : promettre une suppression totale et instantanée alors qu’une copie subsiste chez le sous-traitant vous expose davantage que de documenter clairement les deux régimes.

class DroitsPersonnesConcernees:
    """Implémente les droits RGPD des utilisateurs."""

    def droit_acces(self, user_id: str) -> dict:
        """Retourne toutes les données détenues sur l'utilisateur."""
        return {
            "donnees_personnelles": self._collecter_donnees(user_id),
            "finalites_traitement": ["assistance_client", "amelioration_service"],
            "sous_traitants": ["OpenAI (API LLM)", "PostgreSQL (stockage)"],
            "duree_conservation": "12 mois après dernière activité",
            "source": "Saisie directe par l'utilisateur",
        }

    def droit_effacement(self, user_id: str) -> dict:
        """Supprime toutes les données de l'utilisateur."""
        # Supprimer de la base locale
        donnees_supprimees = self._supprimer_local(user_id)
        # Les données envoyées à l'API OpenAI sont soumises
        # à leur politique de rétention (30 jours max via API)
        return {
            "statut": "supprime",
            "donnees_locales": "supprimées",
            "donnees_openai": "soumises à la rétention de 30 jours",
            "date": datetime.now().isoformat(),
        }

    def droit_portabilite(self, user_id: str) -> dict:
        """Exporte les données dans un format structuré."""
        donnees = self._collecter_donnees(user_id)
        return {
            "format": "JSON",
            "données": donnees,
            "date_export": datetime.now().isoformat(),
        }

    def _collecter_donnees(self, user_id: str) -> dict:
        return {"user_id": user_id, "conversations": [], "profil": {}}

    def _supprimer_local(self, user_id: str) -> int:
        return 0

Formaliser l’analyse d’impact

Pour toute application IA traitant des données personnelles à grande échelle, une Analyse d’Impact relative à la Protection des Données est obligatoire. La structure ci-dessous en donne les rubriques attendues, et l’exemple montre à quoi ressemble une AIPD renseignée pour un chatbot de service client.

Deux champs concentrent l’essentiel de l’attention d’une autorité de contrôle. Le transfert hors UE, d’abord : dès lors que le traitement passe par un fournisseur américain, il faut nommer le destinataire, le pays et la garantie invoquée — ici les clauses contractuelles types complétées par l’accord de sous-traitance. L’analyse des risques, ensuite, qui doit être spécifique au système décrit. Le risque retenu dans l’exemple est la fuite de données personnelles par prompt injection, avec pour mesure d’atténuation les guardrails anti-exfiltration et la modération : tout ce que vous avez construit dans les chapitres précédents trouve ici sa traduction réglementaire.

@dataclass
class AnalyseImpact:
    """Structure d'une AIPD pour un système IA."""
    nom_traitement: str
    description: str
    base_legale: str
    donnees_traitees: list[str]
    destinataires: list[str]
    transferts_hors_ue: list[dict]
    mesures_securite: list[str]
    risques: list[dict]
    avis_dpo: str = ""

aipd_chatbot = AnalyseImpact(
    nom_traitement="Chatbot service client avec IA",
    description="Assistant conversationnel utilisant GPT-5.6 Sol via API OpenAI",
    base_legale="Intérêt légitime (assistance client)",
    donnees_traitees=["prénom", "email", "historique commandes", "messages chat"],
    destinataires=["Équipe support", "OpenAI (sous-traitant API)"],
    transferts_hors_ue=[{
        "destinataire": "OpenAI Inc.",
        "pays": "États-Unis",
        "garantie": "Clauses contractuelles types (CCT) + DPA OpenAI",
    }],
    mesures_securite=[
        "Anonymisation avant envoi à l'API",
        "Chiffrement TLS en transit",
        "Logs d'accès avec rétention 90 jours",
        "Droit d'effacement implémenté",
    ],
    risques=[{
        "description": "Fuite de données personnelles via prompt injection",
        "probabilite": "moyenne",
        "gravite": "elevee",
        "mesure_attenuation": "Guardrails anti-exfiltration + modération",
    }],
)

Points clés à retenir

• Le RGPD s’applique dès qu’un système IA traite des données de résidents européens
• La minimisation des données (anonymisation avant envoi à l’API) est le premier réflexe
• Les droits des personnes (accès, effacement, portabilité) doivent être implémentés
• L’AIPD est obligatoire pour les traitements IA à grande échelle
• Le transfert hors UE se documente par le DPA d’OpenAI et des garanties explicites (CCT, évaluation d’impact du transfert)