Ir al contenido principal
Español— Elegir un idioma
Menú

Privacidad de datos y RGPD

Lección 21 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Privacidad de datos y RGPD
  2. Cómo procesa OpenAI tus datos
  3. Minimización de datos
  4. Canalización conforme al RGPD
  5. Gestión del consentimiento
  6. Derecho de supresión (artículo 17)
  7. Lista de comprobación del RGPD para desarrolladores
  8. Puntos clave

Privacidad de datos y RGPD

Como desarrollador europeo, debes entender cómo fluyen los datos a través de la API de OpenAI y qué pasos seguir para cumplir con el RGPD (Reglamento General de Protección de Datos). Esta lección aborda los aspectos técnicos del cumplimiento. No sustituye el asesoramiento de tu Delegado de Protección de Datos (DPD), pero te proporciona las prácticas de codificación que harán posible su trabajo y que, si se descuidan durante el diseño, resultan extremadamente costosas de corregir más adelante.

Cómo procesa OpenAI tus datos

A través de la API (no ChatGPT)

Distinguir el uso de la API del uso por parte del consumidor es el punto de partida para cualquier debate sobre este tema. Cuando utilizas la API de OpenAI para tu aplicación, los datos no se usan para entrenar modelos: esta es la política de la API, que difiere de la de ChatGPT, y es el argumento que utilizarás para abordar la objeción más común en los comités de seguridad. Sin embargo, los datos se conservan durante 30 días para permitir la detección de abusos y luego se eliminan. Puedes acortar este periodo de retención: puedes solicitar la eliminación anticipada mediante la función de Retención Cero de Datos (Zero Data Retention). Queda un punto por documentar en tu evaluación de impacto: los datos transitan por los servidores de OpenAI, ubicados principalmente en Estados Unidos, lo que constituye una transferencia fuera de la Unión Europea.

# Consulta la política de retención de tu organización
# en platform.openai.com/settings/organization/data-controls

Minimización de datos

El RGPD exige procesar únicamente los datos estrictamente necesarios. Aplica este principio a tus llamadas a la API: en la gran mayoría de los casos, el modelo no necesita conocer el nombre, la dirección de correo electrónico o el número de teléfono de una persona para resumir su solicitud o clasificar su asunto.

La seudonimización reversible responde exactamente a esta necesidad. Antes del envío, cada dato personal se sustituye por un marcador numerado y el mapeo se mantiene en la memoria de tu servidor. La API solo ve [EMAIL_1] y [TEL_1]. Al recibir la respuesta, los marcadores se restauran en el texto generado y el usuario final recibe una respuesta completa sin que las coordenadas hayan salido nunca de tu sistema.

import re

def anonymize_before_send(text: str) -> tuple[str, dict]:
    """Anonimiza los datos personales antes de enviarlos a la API."""
    replacements = {}
    counter = {"email": 0, "phone": 0, "name": 0}

    # Correos electrónicos
    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
    )

    # Números de teléfono franceses
    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:
    """Restaura los datos tras el procesamiento de la API."""
    for key, value in replacements.items():
        text = text.replace(key, value)
    return text

# Uso
from openai import OpenAI
client = OpenAI()

original_text = "Contacta con Jean Dupont en [email protected] o 06 12 34 56 78"

# Anonimizar
anonymous_text, mapping = anonymize_before_send(original_text)
print(f"Enviado a la API: {anonymous_text}")
# Enviado a la API: Contacta con Jean Dupont en [EMAIL_1] o [TEL_1]

# Llamada a la API con datos anonimizados
response = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Resume este mensaje: {anonymous_text}"
)

# Restaurar
result = restore_data(response.output_text, mapping)
print(f"Resultado final: {result}")

Observa detenidamente la salida de este ejemplo: “Jean Dupont” sigue ahí. El contador incluye una entrada para name, pero ninguna expresión regular la rellena; detectar un apellido requiere reconocimiento de entidades nombradas, no un patrón de caracteres. Por tanto, considera esta función como una base sobre la que construir, no como una solución completa de anonimización.

Canalización conforme al RGPD

La minimización por sí sola no basta: la normativa también exige que toda operación de procesamiento se base en una fundamentación jurídica identificada y quede registrada. Esta canalización combina ambos requisitos en cuatro pasos: registrar la finalidad y la base jurídica, minimizar, llamar y restaurar. El identificador del usuario nunca se almacena en texto plano, sino hashificado, de modo que el registro sigue siendo útil para el recuento de operaciones sin constituir por sí mismo un fichero de datos personales.

from datetime import datetime
import json
import hashlib

class GDPRCompliantPipeline:
    """Canalización de procesamiento conforme al RGPD."""

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

    def process(self, text: str, purpose: str,
                legal_basis: str, user_id: str) -> str:
        """Procesa texto cumpliendo con el RGPD."""

        # 1. Registrar la base jurídica del procesamiento
        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. Minimizar datos
        anonymous_text, mapping = anonymize_before_send(text)

        # 3. Llamada a la API
        response = self.client.responses.create(
            model="gpt-5.6-terra",
            input=anonymous_text,
            # Almacenar durante el menor tiempo posible
        )

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

        # 4. Restaurar y devolver
        return restore_data(response.output_text, mapping)

    def export_register(self) -> str:
        """Exporta el registro de actividades de tratamiento (artículo 30 del RGPD)."""
        return json.dumps(self.processing_logs, indent=2, ensure_ascii=False)

# Uso
pipeline = GDPRCompliantPipeline()

result = pipeline.process(
    text="El cliente Pierre Martin desea cancelar su suscripción.",
    purpose="Procesamiento de solicitud de cancelación",
    legal_basis="contract",
    user_id="user-456"
)
print(result)
print(pipeline.export_register())

El parámetro legal_basis merece atención: procesar una solicitud de cancelación corresponde a la ejecución de un contrato, no al consentimiento. Elegir la base jurídica incorrecta es el error más frecuente y con mayores consecuencias, ya que determina los derechos que un usuario puede ejercer sobre dicho procesamiento.

Gestión del consentimiento

Cuando la base jurídica elegida es el consentimiento, este debe recogerse, fecharse, versionarse y, sobre todo, ser revocable. El gestor siguiente almacena el consentimiento por finalidad: aceptar la asistencia con IA no implica aceptar el análisis de texto, y verifica esta coincidencia antes de cada operación de procesamiento. El método de retirada incluye un comentario crítico: borrar el registro de consentimiento no es suficiente; también debes eliminar los datos que dependían de él.

class ConsentManager:
    """Gestiona el consentimiento del usuario para el procesamiento con IA."""

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

    def record_consent(self, user_id: str, purposes: list[str]):
        """Registra el consentimiento del usuario."""
        self.consents[user_id] = {
            "purposes": purposes,
            "date": datetime.now().isoformat(),
            "version": "v1.0"
        }

    def verify_consent(self, user_id: str, purpose: str) -> bool:
        """Comprueba si el usuario ha consentido una finalidad."""
        consent = self.consents.get(user_id)
        if not consent:
            return False
        return purpose in consent["purposes"]

    def withdraw_consent(self, user_id: str):
        """Retira el consentimiento (derecho de retirada)."""
        if user_id in self.consents:
            del self.consents[user_id]
            # Aquí: eliminar también los datos asociados

# Uso
consent = ConsentManager()

# El usuario consiente el procesamiento con IA
consent.record_consent("user-123", ["ai_assistance", "text_analysis"])

# Verificar antes de cada operación de procesamiento
if consent.verify_consent("user-123", "ai_assistance"):
    # Proceder con el procesamiento
    response = client.responses.create(
        model="gpt-5.6-terra",
        input="Pregunta del usuario"
    )
else:
    print("Se requiere consentimiento para este procesamiento")

Derecho de supresión (artículo 17)

Cuando un usuario solicita la supresión de sus datos, tu obligación va más allá de la base de datos de la aplicación. Debes barrer todas las ubicaciones: datos locales, registros que contengan información personal (a menudo olvidados) y documentar la operación para justificarla. Por parte de la API, la acción ya está cubierta por la política de retención: los datos enviados desaparecen automáticamente tras treinta días, o inmediatamente si se activa la Retención Cero de Datos.

def exercise_right_to_erasure(user_id: str):
    """Implementa el derecho de supresión del RGPD."""

    # 1. Eliminar datos locales
    # delete_user_data(user_id)

    # 2. Los datos enviados a la API de OpenAI se eliminan
    # automáticamente tras 30 días (o inmediatamente
    # si la Retención Cero de Datos está activada)

    # 3. Eliminar registros que contengan datos personales
    # delete_user_logs(user_id)

    # 4. Documentar la eliminación
    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")

Lista de comprobación del RGPD para desarrolladores

  • Identifica la base jurídica de cada operación de procesamiento (consentimiento, contrato, etc.)
  • Minimiza los datos enviados a la API (anonimización)
  • Mantén un registro de actividades de tratamiento (artículo 30)
  • Implementa el derecho de acceso y el derecho de supresión
  • Documenta las transferencias fuera de la UE (OpenAI = servidores en EE. UU.)
  • Activa la Retención Cero de Datos si es posible
  • Nunca registres datos personales en texto plano

Puntos clave

  • La API de OpenAI NO reentrena sus modelos con tus datos
  • Anonimiza los datos personales antes de cada llamada a la API
  • Mantén un registro de actividades de tratamiento conforme al artículo 30
  • Implementa los derechos del RGPD: acceso, rectificación, supresión, portabilidad
  • Las transferencias de datos fuera de la UE requieren garantías (cláusulas contractuales tipo)
  • Documenta cada decisión relativa a la protección de datos