RGPD y protección de datos con OpenAI
En esta página
La IA y el RGPD: un marco innegociable
El Reglamento General de Protección de Datos (RGPD) se aplica a cualquier aplicación que procese datos personales de residentes europeos, incluidas las aplicaciones construidas sobre modelos de lenguaje de gran tamaño (LLM). No existen excepciones para la inteligencia artificial. Esto suele confundir a los equipos técnicos: buscan normativas específicas para la IA cuando el texto aplicable lleva años vigente y no ha cambiado. En 2026, las acciones de ejecución se centran cada vez más en los sistemas de IA. Utilizar las API de OpenAI en este contexto implica menos aprender una nueva ley y más traducir requisitos legales conocidos a una arquitectura novedosa.
Siete principios, adaptados a un sistema LLM
El RGPD se basa en siete principios fundamentales, cada uno de los cuales adquiere un significado específico cuando un modelo de lenguaje entra en la cadena de procesamiento.
| Principio | Aplicación en IA |
|---|---|
| Licitud | Base jurídica para enviar datos a la API (consentimiento, interés legítimo, contrato) |
| Minimización de datos | Enviar solo los datos estrictamente necesarios para el modelo |
| Limitación de la finalidad | Los datos enviados deben servir únicamente para la finalidad declarada |
| Exactitud | Las salidas del modelo pueden ser inexactas: informa al usuario |
| Limitación del plazo de conservación | Consulta la política de retención de OpenAI y elimina los datos en el lado del cliente |
| Seguridad | Cifrado en tránsito, control de acceso, auditoría de registros |
| Responsabilidad proactiva | Documenta las decisiones y sé capaz de demostrar el cumplimiento |
Dos principios suelen pillar desprevenidos a los equipos. Primero, la exactitud: esto convierte las alucinaciones de un problema de calidad en uno regulatorio. Cuando un modelo genera información falsa sobre una persona identificada, esa persona tiene derecho a la rectificación. Segundo, la responsabilidad proactiva: no basta con cumplir; debes poder demostrarlo. Esto transforma la documentación de una buena práctica a una obligación legal.
Minimización: la medida que resuelve la mayoría de los problemas
De todas las medidas disponibles, la seudonimización antes de enviar los datos ofrece el mejor equilibrio entre esfuerzo y reducción de riesgos. La lógica es simple: lo que nunca sale de tu sistema no puede filtrarse a un subencargado, no plantea dudas durante las transferencias fuera de la UE y no complica las solicitudes de supresión.
El mecanismo siguiente sustituye cada dato identificativo por un token estable, mantiene la correspondencia en la memoria local y restaura los valores originales en la respuesta. El usuario final ve «Sr. Dupont», el modelo solo ve «[PERSONA_1]» y la función del servicio permanece totalmente intacta: el asistente puede redactar su respuesta porque nunca necesitó el apellido real.
El comentario sobre los nombres no es decorativo: el patrón captura solo las formas precedidas por un título. Un nombre suyo se colará. En producción, un modelo de reconocimiento de entidades nombradas (NER) se hará cargo, y tener esta advertencia explícita en el código es preferible a una falsa confianza.
import re
class DataMinimizer:
"""Anonimiza datos personales antes de enviarlos a la API."""
def __init__(self):
self.mappings: dict[str, str] = {}
self.counter = 0
def anonymize(self, text: str) -> str:
"""Sustituye datos personales por marcadores de posición."""
# Correos electrónicos
text = re.sub(
r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}",
lambda m: self._replace(m.group(), "EMAIL"),
text,
)
# Números de teléfono franceses
text = re.sub(
r"(?:0|\+33)[1-9](?:[\s.-]?\d{2}){4}",
lambda m: self._replace(m.group(), "PHONE"),
text,
)
# Nombres (patrón simplificado: usar NER en producción)
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:
"""Restaura los datos originales en la respuesta."""
reverse = {v: k for k, v in self.mappings.items()}
for placeholder, original in reverse.items():
text = text.replace(placeholder, original)
return text
# Uso
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."
# Tras la respuesta del modelo
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}")
Configurar el servicio y recabar el consentimiento
En el lado del proveedor, debes conocer esta regla: los datos enviados a través de la API no se utilizan para el entrenamiento por defecto, contrariamente a lo que muchos suponen por analogía con las interfaces de consumo. Esto no te exime de verificar la configuración de tu organización en la plataforma y documentar dicha verificación.
from openai import OpenAI
# Con la API, tus datos NO se utilizan para entrenamiento por defecto
# Pero verifica la configuración de tu organización en platform.openai.com
client = OpenAI()
# El endpoint de la API de Responses respeta la política de retención
response = client.chat.completions.create(
model="gpt-5.6-sol",
messages=[{"role": "user", "content": "Hello"}],
# store=False desactiva el almacenamiento en el lado de OpenAI si está disponible
)
En el lado del usuario, el consentimiento se gestiona por finalidad, no de forma global, lo que explica la estructura aquí: un usuario puede aceptar la asistencia conversacional mientras rechaza que sus intercambios se utilicen para mejorar el servicio. La versión de la política se registra junto con el consentimiento, un detalle crítico el día que actualices dicha política. Sin este rastro, no sabrás quién aceptó qué. Por último, la retirada del consentimiento desencadena la eliminación inmediata, porque conservar datos tras la retirada es exactamente el escenario que convierte una auditoría rutinaria en una acción de ejecución.
class ConsentManager:
"""Gestiona el consentimiento del usuario para el procesamiento con IA."""
def __init__(self):
self.consent_records: dict[str, dict] = {}
def record_consent(self, user_id: str, purposes: list[str]):
"""Registra el consentimiento explícito del usuario."""
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:
"""Comprueba si el usuario ha consentido una finalidad específica."""
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):
"""Retira el consentimiento y desencadena la eliminación de datos."""
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):
"""Elimina todos los datos asociados al usuario."""
# Eliminar el historial de conversaciones
# Eliminar registros que contengan datos personales
# Notificar a los subencargados (OpenAI) si corresponde
print(f"Data deleted for {user_id}")
Responder a las solicitudes de los interesados
Los derechos de acceso, supresión y portabilidad deben implementarse antes de que llegue la primera solicitud, porque el plazo de respuesta de un mes desaparece rápidamente si aún estás escribiendo el código. El derecho de acceso exige más que datos en bruto: debes proporcionar las finalidades, la lista de subencargados y los plazos de conservación, información que es mejor consolidar con antelación.
El derecho a la supresión requiere una revisión cuidadosa del código. La respuesta distingue explícitamente entre los datos locales, eliminados de inmediato, y los datos enviados a la API, que quedan sujetos a la política de retención del proveedor. Esta honestidad es obligatoria: prometer una eliminación total e instantánea mientras una copia permanece en un subencargado te expone más que documentar claramente ambos regímenes.
class DataSubjectRights:
"""Implementa los derechos del RGPD para los usuarios."""
def right_of_access(self, user_id: str) -> dict:
"""Devuelve todos los datos retenidos sobre el usuario."""
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:
"""Elimina todos los datos del usuario."""
# Eliminar de la base de datos local
deleted_local = self._delete_local(user_id)
# Los datos enviados a la API de OpenAI están sujetos
# a su política de retención (máx. 30 días vía 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:
"""Exporta los datos en un formato estructurado."""
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
Formalizar la evaluación de impacto
Para cualquier aplicación de IA que procese datos personales a gran escala, es obligatoria una Evaluación de Impacto en la Protección de Datos (EIPD). La estructura siguiente muestra las secciones esperadas, y el ejemplo ilustra el aspecto de una EIPD completada para un chatbot de atención al cliente.
Dos campos atraen la mayor parte de la atención de una autoridad de control. Primero, las transferencias fuera de la UE: siempre que el procesamiento pase por un proveedor estadounidense, debes nombrar al destinatario, el país y la garantía invocada; aquí, las Cláusulas Contractuales Tipo (CCT) complementadas por el Acuerdo de Procesamiento de Datos de OpenAI. Segundo, el análisis de riesgos, que debe ser específico para el sistema descrito. El riesgo seleccionado en el ejemplo es la filtración de datos personales mediante inyección de prompts, y las medidas de mitigación son barreras antiexfiltración y moderación: todo lo que construiste en capítulos anteriores encuentra aquí su traducción regulatoria.
@dataclass
class ImpactAssessment:
"""Estructura de una EIPD para un sistema de IA."""
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",
}],
)
Puntos clave
- El RGPD se aplica tan pronto como un sistema de IA procesa datos de residentes europeos
- La minimización de datos (anonimización antes de enviar a la API) es el primer reflejo
- Los derechos de los interesados (acceso, supresión, portabilidad) deben implementarse
- Una EIPD es obligatoria para el procesamiento de IA a gran escala
- Las transferencias fuera de la UE se documentan mediante el DPA de OpenAI y garantías explícitas (CCT, evaluación de impacto de la transferencia)