# Como implementar o direito de portabilidade de dados de CPF

> Aprenda a implementar o direito de portabilidade de dados de CPF conforme a LGPD, com exemplos de código e fluxos técnicos completos.

**Publicado:** 27/04/2025
**Autor:** Redação CPFHub.io
**URL:** https://cpfhub.io/blog/implementar-direito-portabilidade-dados-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

```python
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

```bash
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

```json
{
 "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

```python
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

```python
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](https://www.gov.br/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.

### Leia também

- [LGPD: CPF é dado pessoal sensível ou não? Entenda a classificação correta](https://cpfhub.io/blog/lgpd-cpf-e-dado-pessoal-sensivel-ou-nao-entenda-a-classificacao-correta)
- [Retenção de dados de CPF: por quanto tempo é permitido armazenar](https://cpfhub.io/blog/retencao-de-dados-de-cpf-por-quanto-tempo-e-permitido-armazenar)
- [Anonimização e pseudonimização de CPF: técnicas e quando aplicar](https://cpfhub.io/blog/anonimizacao-e-pseudonimizacao-de-cpf-tecnicas-e-quando-aplicar)
- [Como implementar controle de acesso baseado em função (RBAC) para dados de CPF](https://cpfhub.io/blog/como-implementar-controle-de-acesso-baseado-em-funcao-rbac-para-dados-de-cpf)

---

## 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](https://www.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.