Como implementar o direito de portabilidade de dados de CPF

Para implementar o direito de portabilidade de dados de CPF conforme a LGPD, crie um endpoint autenticado que receba a solicitação do titular, verifique a identidade via API de CPF, consolide os dados de todos os sistemas internos e entregue um pacote JSON criptografado em até 15 dias — com log de auditoria de cada etapa.

Introdução

O direito de portabilidade de dados é um dos pilares da LGPD e garante ao titular a possibilidade de transferir seus dados pessoais de um controlador para outro. Quando esses dados incluem o CPF — um identificador central no Brasil — a implementação técnica exige cuidados específicos para garantir integridade, segurança e conformidade.

O que é o direito de portabilidade

O artigo 18, inciso V, da LGPD estabelece que o titular tem o direito de solicitar a portabilidade de seus dados a outro fornecedor de serviço ou produto. Esse direito se aplica aos dados tratados com base no consentimento ou na execução de contrato.

Requisitos fundamentais

• Formato estruturado: os dados devem ser fornecidos em formato aberto e legível por máquina.
• Interoperabilidade: o formato deve permitir que o novo controlador importe os dados sem dificuldade.
• Prazo: a solicitação deve ser atendida em até 15 dias.
• Gratuidade: o titular não pode ser cobrado pela portabilidade.

Limitações do direito

A portabilidade não inclui dados que já tenham sido anonimizados, dados de terceiros ou informações que constituam segredo comercial ou industrial.

Arquitetura do fluxo de portabilidade

Um sistema de portabilidade de dados de CPF deve contemplar as seguintes etapas:

1. Recebimento da solicitação: canal de atendimento onde o titular faz o pedido.
2. Verificação de identidade: confirmação de que o solicitante é de fato o titular do CPF.
3. Coleta dos dados: extração dos dados pessoais associados ao CPF.
4. Formatação: conversão dos dados para formato padronizado (JSON ou CSV).
5. Entrega: disponibilização ao titular ou envio direto ao novo controlador.
6. Registro: documentação da operação para fins de auditoria.

Implementação técnica passo a passo

Endpoint de solicitação de portabilidade

from flask import Flask, request, jsonify
from datetime import datetime, timezone
import requests
import json
import hashlib

app = Flask(__name__)

@app.route("/api/portabilidade/solicitar", methods=["POST"])
def solicitar_portabilidade():
    """Endpoint para receber solicitações de portabilidade."""

    dados = request.json
    cpf = dados.get("cpf")
    email_titular = dados.get("email")
    controlador_destino = dados.get("controlador_destino")

    if not cpf or not email_titular:
        return jsonify({"error": "CPF e e-mail são obrigatórios"}), 400

    # Verificar identidade do titular
    if not verificar_identidade(cpf, email_titular):
        return jsonify({"error": "Falha na verificação de identidade"}), 403

    # Criar protocolo de solicitação
    protocolo = {
        "id": hashlib.sha256(f"{cpf}{datetime.now().isoformat()}".encode()).hexdigest()[:16],
        "cpf_masked": f"***.{cpf[3:6]}.***-{cpf[-2:]}",
        "data_solicitacao": datetime.now(timezone.utc).isoformat(),
        "prazo_limite": "15 dias úteis",
        "status": "em_processamento",
        "controlador_destino": controlador_destino
    }

    # Registrar solicitação no banco de dados
    salvar_solicitacao(protocolo)

    return jsonify({
        "success": True,
        "protocolo": protocolo["id"],
        "mensagem": "Solicitação recebida. Prazo de até 15 dias úteis."
    }), 201

def verificar_identidade(cpf: str, email: str) -> bool:
    """Verifica a identidade do titular consultando dados na API."""

    try:
        response = requests.get(
            f"https://api.cpfhub.io/cpf/{cpf}",
            headers={
                "x-api-key": "SUA_API_KEY",
                "Accept": "application/json"
            },
            timeout=30
        )

        if response.status_code == 200:
            dados = response.json()
            # Lógica de verificação complementar
            return dados.get("success", False)

    except requests.exceptions.Timeout:
        print("[ERROR] Timeout na verificação de identidade")

    return False

def salvar_solicitacao(protocolo: dict):
    """Salva a solicitação no sistema de registros."""
    with open("portabilidade_log.jsonl", "a") as f:
        f.write(json.dumps(protocolo) + "\n")

Consulta via cURL para validação

curl -X GET "https://api.cpfhub.io/cpf/12345678901" \
    -H "x-api-key: SUA_API_KEY" \
    -H "Accept: application/json" \
    --max-time 30

Formato de exportação dos dados

A LGPD exige que os dados sejam entregues em formato estruturado e interoperável. Recomendamos o uso de JSON como formato primário e CSV como alternativa.

Estrutura JSON de portabilidade

{
    "portabilidade": {
        "protocolo": "a1b2c3d4e5f67890",
        "data_exportacao": "2025-04-27T10:00:00.000Z",
        "controlador_origem": "Empresa XYZ Ltda",
        "cnpj_origem": "12.345.678/0001-00"
    },
    "titular": {
        "cpf": "123.456.789-01",
        "nome": "João da Silva",
        "data_nascimento": "1990-05-15",
        "genero": "M"
    },
    "dados_tratados": {
        "historico_consultas": [
            {
                "data": "2025-03-10",
                "finalidade": "verificacao_cadastral",
                "base_legal": "execucao_contrato"
            }
        ],
        "consentimentos_ativos": [
            {
                "finalidade": "marketing_personalizado",
                "data_consentimento": "2025-01-15",
                "canal": "aplicativo_mobile"
            }
        ]
    },
    "metadados": {
        "formato_versao": "1.0",
        "charset": "UTF-8",
        "hash_integridade": "sha256:abc123def456..."
    }
}

Segurança na transferência

Criptografia do pacote de dados

from cryptography.fernet import Fernet
import json

def criptografar_dados_portabilidade(dados: dict, chave: bytes) -> bytes:
    """Criptografa os dados de portabilidade para transferência segura."""

    fernet = Fernet(chave)
    dados_json = json.dumps(dados, ensure_ascii=False).encode("utf-8")
    dados_criptografados = fernet.encrypt(dados_json)

    return dados_criptografados

def descriptografar_dados_portabilidade(dados_cripto: bytes, chave: bytes) -> dict:
    """Descriptografa os dados recebidos via portabilidade."""

    fernet = Fernet(chave)
    dados_json = fernet.decrypt(dados_cripto)

    return json.loads(dados_json.decode("utf-8"))

# Gerar chave compartilhada entre controladores
chave = Fernet.generate_key()

Hash de integridade

Inclua um hash SHA-256 dos dados exportados para que o controlador de destino possa verificar a integridade do pacote recebido.

Registro e auditoria

Toda operação de portabilidade deve ser registrada com os seguintes campos:

• Identificador do protocolo.
• CPF mascarado do titular.
• Data e hora da solicitação e da entrega.
• Controlador de destino.
• Campos de dados transferidos.
• Base legal utilizada.

Exemplo de log de auditoria

import logging

logging.basicConfig(
    filename="portabilidade_audit.log",
    level=logging.INFO,
    format="%(asctime)s | %(levelname)s | %(message)s"
)

def registrar_portabilidade(protocolo: str, cpf_masked: str, destino: str):
    """Registra a operação de portabilidade no log de auditoria."""

    logging.info(
        f"PORTABILIDADE | protocolo={protocolo} | "
        f"cpf={cpf_masked} | destino={destino} | "
        f"status=concluida"
    )

Desafios comuns e como resolvê-los

Verificação de identidade

Um dos maiores desafios é confirmar que quem solicita a portabilidade é de fato o titular do CPF. Utilize múltiplos fatores de verificação — e-mail cadastrado, token SMS e perguntas de segurança.

Incompatibilidade de formatos

Nem todos os controladores utilizam o mesmo padrão de dados. Defina schemas claros e documente o formato de exportação para facilitar a importação pelo controlador de destino.

Prazo de 15 dias

Automatize o máximo possível do processo para cumprir o prazo legal. Sistemas manuais estão propensos a atrasos e inconsistências.

Dados em múltiplos sistemas

Quando os dados de CPF estão distribuídos em diferentes bancos de dados ou microserviços, é necessário um orquestrador que consolide todas as informações antes da exportação.

A ANPD publicou orientações sobre o exercício dos direitos dos titulares, incluindo o direito de portabilidade, que esclarecem os prazos, formatos aceitos e responsabilidades do controlador no atendimento dessas solicitações.

Perguntas frequentes

Quais dados de CPF precisam ser incluídos no pacote de portabilidade?

Devem constar todos os dados pessoais associados ao CPF que foram coletados e tratados com base no consentimento ou execução de contrato: dados cadastrais, histórico de interações, preferências declaradas e consentimentos ativos. Dados anonimizados, dados de terceiros e informações que constituam segredo comercial ficam de fora.

É obrigatório verificar a identidade do titular antes de entregar o pacote de portabilidade?

Sim. Entregar dados pessoais de CPF para um solicitante não verificado configura vazamento de dados e pode gerar sanções da ANPD. Use ao menos dois fatores de verificação: algo que o titular sabe (senha) e algo que o titular possui (token no e-mail ou SMS cadastrado).

O controlador de destino pode recusar o pacote de portabilidade?

O controlador de destino não é obrigado a aceitar dados em qualquer formato. Por isso, o schema do pacote de exportação deve ser documentado e, preferencialmente, seguir padrões interoperáveis. O formato JSON com campos padronizados é o mais amplamente aceito e facilita a importação por sistemas heterogêneos.

Como garantir que o prazo de 15 dias seja cumprido sem processo manual?

Implemente um sistema de tickets com SLA automático: ao receber a solicitação, crie um job agendado para 14 dias que executa a exportação e envia o pacote. Monitore o status de cada solicitação em um dashboard interno com alertas para qualquer ticket próximo ao vencimento sem conclusão.

Conclusão

Implementar o direito de portabilidade de dados de CPF não é apenas uma obrigação legal — é uma oportunidade de demonstrar comprometimento com a transparência e o respeito ao titular. Com um fluxo técnico bem estruturado, segurança na transferência e registros de auditoria completos, sua empresa estará preparada para atender às solicitações dentro do prazo e com total conformidade.

Cadastre-se em cpfhub.io — 50 consultas mensais gratuitas, sem cartão de crédito — e utilize a API para verificar a identidade do titular no fluxo de portabilidade com segurança e rastreabilidade.