Privacidade de Dados e RGPD
Nesta página
Privacidade de Dados e RGPD
Enquanto programador europeu, deve compreender como os dados fluem através da API da OpenAI e que medidas tomar para cumprir o RGPD (Regulamento Geral sobre a Proteção de Dados). Esta lição abrange os aspetos técnicos da conformidade. Não substitui o aconselhamento do seu Encarregado de Proteção de Dados (DPO), mas fornece-lhe as práticas de codificação que tornarão o trabalho dele possível — e que, se negligenciadas durante a conceção, se tornarão extremamente dispendiosas de corrigir mais tarde.
Como a OpenAI Processa os Seus Dados
Através da API (não o ChatGPT)
Distinguir a utilização da API do uso por consumidores é o ponto de partida para qualquer discussão sobre este tema. Quando utiliza a API da OpenAI para a sua aplicação, os dados não são usados para treinar modelos: esta é a política da API, que difere da do ChatGPT, e é o argumento que utilizará para responder à objeção mais comum nos comités de segurança. No entanto, os dados são retidos por 30 dias para permitir a deteção de abusos, sendo depois eliminados. Pode encurtar este período de retenção: pode solicitar a eliminação antecipada através da funcionalidade Zero Data Retention. Resta um ponto a documentar na sua avaliação de impacto — os dados transitam pelos servidores da OpenAI, localizados principalmente nos Estados Unidos, o que constitui uma transferência para fora da União Europeia.
# Check your organization's retention policy
# on platform.openai.com/settings/organization/data-controls
Minimização de Dados
O RGPD exige o processamento apenas de dados estritamente necessários. Aplique este princípio às suas chamadas à API: na vasta maioria dos casos, o modelo não precisa de saber o nome, o endereço de e-mail ou o número de telefone de uma pessoa para resumir o seu pedido ou classificar o seu assunto.
A pseudonimização reversível responde exatamente a esta necessidade. Antes do envio, cada dado pessoal é substituído por um marcador numerado, e o mapeamento é mantido na memória do seu servidor. A API vê apenas [EMAIL_1] e [TEL_1]. No retorno, os marcadores são restaurados no texto gerado, e o utilizador final recebe uma resposta completa sem que as coordenadas alguma vez saiam do seu sistema.
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}")
Observe atentamente o resultado deste exemplo: “Jean Dupont” ainda lá está. O contador inclui uma entrada para name, mas nenhuma expressão regular a preenche — detetar um apelido requer reconhecimento de entidades nomeadas, não um padrão de carateres. Portanto, considere esta função uma base sobre a qual construir, e não uma solução completa de anonimização.
Pipeline em Conformidade com o RGPD
A minimização por si só não é suficiente: o regulamento exige também que cada operação de processamento assente numa base jurídica identificada e seja registada. Este pipeline combina ambos os requisitos em quatro passos — registar a finalidade e a base jurídica, minimizar, chamar, restaurar. O identificador do utilizador nunca é armazenado em texto simples, mas sim com hash, de modo que o registo permaneça utilizável para contagem de operações sem constituir, por si só, um ficheiro de dados pessoais.
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())
O parâmetro legal_basis merece atenção: o processamento de um pedido de cancelamento enquadra-se na execução de um contrato, e não no consentimento. Escolher a base jurídica errada é o erro mais frequente e consequente, pois determina os direitos que um utilizador pode exercer sobre esse processamento.
Gestão de Consentimento
Quando a base jurídica escolhida é o consentimento, este deve ser recolhido, datado, versionado e, acima de tudo, revogável. O gestor abaixo armazena o consentimento por finalidade — aceitar assistência de IA não implica aceitar a análise de texto — e verifica esta correspondência antes de cada operação de processamento. O método de retirada contém um comentário crítico: eliminar o registo de consentimento não é suficiente; deve também eliminar os dados que dele dependiam.
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")
Direito ao Apagamento (Artigo 17.º)
Quando um utilizador solicita o apagamento dos seus dados, a sua obrigação estende-se para além da base de dados da aplicação. Deve varrer todas as localizações: dados locais, registos (logs) contendo informações pessoais — frequentemente esquecidos — e documentar a operação para a justificar. Do lado da API, a ação já está coberta pela política de retenção: os dados enviados desaparecem automaticamente após trinta dias, ou imediatamente se a funcionalidade Zero Data Retention estiver ativada.
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")
Lista de Verificação do RGPD para Programadores
- Identificar a base jurídica para cada operação de processamento (consentimento, contrato, etc.)
- Minimizar os dados enviados para a API (anonimização)
- Manter um registo das atividades de processamento (Artigo 30.º)
- Implementar o direito de acesso e o direito ao apagamento
- Documentar as transferências para fora da UE (OpenAI = servidores nos EUA)
- Ativar a Zero Data Retention, se possível
- Nunca registar dados pessoais em texto simples
Pontos-chave
- A API da OpenAI NÃO retreina os seus modelos com os seus dados
- Anonimize os dados pessoais antes de cada chamada à API
- Mantenha um registo das atividades de processamento em conformidade com o Artigo 30.º
- Implemente os direitos do RGPD: acesso, retificação, apagamento, portabilidade
- As transferências de dados para fora da UE exigem garantias (cláusulas contratuais padrão)
- Documente cada decisão relativa à proteção de dados