Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Privacidade de Dados e RGPD

Aula 21 de 22 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Privacidade de Dados e RGPD
  2. Como a OpenAI Processa os Seus Dados
  3. Minimização de Dados
  4. Pipeline em Conformidade com o RGPD
  5. Gestão de Consentimento
  6. Direito ao Apagamento (Artigo 17.º)
  7. Lista de Verificação do RGPD para Programadores
  8. Pontos-chave

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