# Direitos do titular: fluxo completo de atendimento para dados de CPF

> Guia completo para implementar o fluxo de atendimento aos direitos do titular de dados de CPF conforme a LGPD, com exemplos técnicos.

**Publicado:** 08/12/2025
**Autor:** Redação CPFHub.io
**URL:** https://cpfhub.io/blog/direitos-titular-fluxo-atendimento-dados-cpf

---

A LGPD garante aos titulares de CPF o direito de acessar, corrigir, portar e solicitar a exclusão dos seus dados — e toda empresa que processa esses dados precisa de um fluxo de atendimento estruturado, com prazos documentados e trilha de auditoria. A API da CPFHub.io permite verificar a identidade do solicitante antes de executar qualquer operação, garantindo que os dados sejam entregues apenas ao titular legítimo.

## Introdução

A LGPD garante aos titulares de dados pessoais um conjunto robusto de direitos que devem ser respeitados por qualquer empresa que processe dados de CPF. Do acesso à exclusão, da correção à portabilidade, cada direito exige um fluxo de atendimento estruturado, com prazos definidos e registros de auditoria. Não basta ter um canal de atendimento — é preciso que ele funcione de forma eficiente e documentada.

## Direitos do titular na LGPD

O [artigo 18 da LGPD](https://www.planalto.gov.br/ccivil_03/_ato2019-2022/2018/lei/l13709.htm) lista os seguintes direitos:

1. **Confirmação de tratamento**: saber se a empresa trata seus dados.
2. **Acesso**: obter cópia dos dados pessoais tratados.
3. **Correção**: solicitar a atualização de dados incompletos ou incorretos.
4. **Anonimização, bloqueio ou eliminação**: para dados desnecessários, excessivos ou tratados irregularmente.
5. **Portabilidade**: transferir dados a outro controlador.
6. **Eliminação**: excluir dados tratados com base no consentimento.
7. **Informação sobre compartilhamento**: saber com quem os dados foram compartilhados.
8. **Informação sobre o consentimento**: saber que pode negar consentimento e as consequências.
9. **Revogação do consentimento**: revogar autorização previamente concedida.

## Sistema de atendimento ao titular

### Modelo de dados e gerenciador de solicitações

```python
import json
import hashlib
import sqlite3
from datetime import datetime, timezone, timedelta
from enum import Enum
from typing import Optional, List
import requests

class TipoDireito(Enum):
 CONFIRMACAO = "confirmacao_tratamento"
 ACESSO = "acesso_dados"
 CORRECAO = "correcao_dados"
 ELIMINACAO = "eliminacao_dados"
 PORTABILIDADE = "portabilidade"
 INFORMACAO_COMPARTILHAMENTO = "info_compartilhamento"
 REVOGACAO_CONSENTIMENTO = "revogacao_consentimento"
 ANONIMIZACAO = "anonimizacao"

class StatusSolicitacao(Enum):
 RECEBIDA = "recebida"
 EM_ANALISE = "em_analise"
 EM_PROCESSAMENTO = "em_processamento"
 CONCLUIDA = "concluida"
 INDEFERIDA = "indeferida"

class GerenciadorDireitosTitular:
 """Gerencia solicitações de direitos do titular para dados de CPF."""

 PRAZO_DIAS = 15 # Prazo legal para atendimento

 def __init__(self, db_path: str = "direitos_titular.db"):
 self.conn = sqlite3.connect(db_path, check_same_thread=False)
 self._criar_tabelas()

 def _criar_tabelas(self):
 self.conn.executescript("""
 CREATE TABLE IF NOT EXISTS solicitacoes (
 protocolo TEXT PRIMARY KEY,
 cpf_hash TEXT NOT NULL,
 tipo_direito TEXT NOT NULL,
 status TEXT NOT NULL,
 detalhes TEXT,
 criado_em TEXT NOT NULL,
 prazo_limite TEXT NOT NULL,
 concluido_em TEXT,
 resposta TEXT,
 atendente TEXT
 );

 CREATE TABLE IF NOT EXISTS historico_solicitacoes (
 id INTEGER PRIMARY KEY AUTOINCREMENT,
 protocolo TEXT NOT NULL,
 status_anterior TEXT,
 status_novo TEXT NOT NULL,
 timestamp TEXT NOT NULL,
 observacao TEXT
 );
 """)
 self.conn.commit()

 def abrir_solicitacao(
 self,
 cpf: str,
 tipo_direito: TipoDireito,
 detalhes: str = ""
 ) -> dict:
 """Abre uma nova solicitação de direito do titular."""

 cpf_hash = hashlib.sha256(cpf.encode()).hexdigest()
 protocolo = f"SOL-{datetime.now().strftime('%Y%m%d')}-{hashlib.sha256(f'{cpf}{datetime.now().isoformat()}'.encode()).hexdigest()[:8].upper()}"

 agora = datetime.now(timezone.utc)
 prazo = agora + timedelta(days=self.PRAZO_DIAS)

 self.conn.execute(
 """INSERT INTO solicitacoes
 (protocolo, cpf_hash, tipo_direito, status, detalhes, criado_em, prazo_limite)
 VALUES (?, ?, ?, ?, ?, ?, ?)""",
 (protocolo, cpf_hash, tipo_direito.value,
 StatusSolicitacao.RECEBIDA.value, detalhes,
 agora.isoformat(), prazo.isoformat())
 )

 self._registrar_historico(protocolo, None, StatusSolicitacao.RECEBIDA.value, "Solicitação recebida")
 self.conn.commit()

 return {
 "protocolo": protocolo,
 "tipo_direito": tipo_direito.value,
 "status": StatusSolicitacao.RECEBIDA.value,
 "criado_em": agora.isoformat(),
 "prazo_limite": prazo.isoformat()
 }

 def processar_solicitacao(self, protocolo: str, atendente: str):
 """Atualiza o status da solicitação para em processamento."""

 self.conn.execute(
 "UPDATE solicitacoes SET status = ?, atendente = ? WHERE protocolo = ?",
 (StatusSolicitacao.EM_PROCESSAMENTO.value, atendente, protocolo)
 )
 self._registrar_historico(
 protocolo, StatusSolicitacao.EM_ANALISE.value,
 StatusSolicitacao.EM_PROCESSAMENTO.value,
 f"Atendente: {atendente}"
 )
 self.conn.commit()

 def concluir_solicitacao(self, protocolo: str, resposta: str):
 """Conclui a solicitação com a resposta ao titular."""

 agora = datetime.now(timezone.utc).isoformat()
 self.conn.execute(
 "UPDATE solicitacoes SET status = ?, concluido_em = ?, resposta = ? WHERE protocolo = ?",
 (StatusSolicitacao.CONCLUIDA.value, agora, resposta, protocolo)
 )
 self._registrar_historico(
 protocolo, StatusSolicitacao.EM_PROCESSAMENTO.value,
 StatusSolicitacao.CONCLUIDA.value,
 "Solicitação concluída"
 )
 self.conn.commit()

 def consultar_status(self, protocolo: str) -> Optional[dict]:
 """Consulta o status de uma solicitação."""

 cursor = self.conn.execute(
 "SELECT protocolo, tipo_direito, status, criado_em, prazo_limite, concluido_em FROM solicitacoes WHERE protocolo = ?",
 (protocolo,)
 )
 row = cursor.fetchone()
 if row:
 return {
 "protocolo": row[0],
 "tipo_direito": row[1],
 "status": row[2],
 "criado_em": row[3],
 "prazo_limite": row[4],
 "concluido_em": row[5]
 }
 return None

 def solicitacoes_pendentes(self) -> List[dict]:
 """Lista solicitações pendentes próximas do prazo."""

 cursor = self.conn.execute(
 "SELECT protocolo, tipo_direito, status, prazo_limite FROM solicitacoes WHERE status != 'concluida' AND status != 'indeferida' ORDER BY prazo_limite ASC"
 )
 return [
 {"protocolo": r[0], "tipo": r[1], "status": r[2], "prazo": r[3]}
 for r in cursor.fetchall()
 ]

 def _registrar_historico(self, protocolo, status_anterior, status_novo, obs):
 self.conn.execute(
 "INSERT INTO historico_solicitacoes (protocolo, status_anterior, status_novo, timestamp, observacao) VALUES (?, ?, ?, ?, ?)",
 (protocolo, status_anterior, status_novo,
 datetime.now(timezone.utc).isoformat(), obs)
 )
```

## Processamento de cada tipo de direito

### Direito de acesso

```python
def processar_acesso(cpf: str, api_key: str) -> dict:
 """Processa solicitação de acesso aos dados de CPF."""

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

 if response.status_code == 200:
 dados = response.json()["data"]
 return {
 "dados_tratados": dados,
 "base_legal": "execucao_contrato",
 "finalidade": "verificacao_cadastral",
 "data_coleta": "2025-01-15",
 "compartilhado_com": ["Provedor de pagamento XYZ"],
 "retencao_prevista": "365 dias"
 }

 except requests.exceptions.Timeout:
 return {"error": "Timeout ao recuperar dados"}

 return {"error": "Dados não encontrados"}
```

### Verificação via cURL

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

## Fluxo visual do atendimento

```
Titular -> [Solicitação] -> Recebida -> Verificação de Identidade
 -> Em Análise -> Classificação do Direito -> Em Processamento
 -> Execução da Ação -> Geração da Resposta -> Concluída
 -> Notificação ao Titular -> Registro de Auditoria
```

### Prazos por tipo de direito

| Direito | Prazo LGPD | Complexidade |
|---------|-----------|-------------|
| Confirmação de tratamento | Imediato (formato simplificado) ou 15 dias | Baixa |
| Acesso aos dados | 15 dias | Média |
| Correção | 15 dias | Baixa |
| Eliminação | 15 dias | Alta |
| Portabilidade | 15 dias | Alta |
| Revogação de consentimento | Imediato | Baixa |

## Verificação de identidade do solicitante

Antes de atender qualquer solicitação, confirme que o solicitante é de fato o titular do CPF. Utilize múltiplos fatores:

- E-mail vinculado ao cadastro.
- Token SMS para o telefone cadastrado.
- Perguntas de segurança.
- Documento de identidade (para solicitações de alto risco).

## Métricas e SLAs

Monitore os seguintes indicadores:

- **Tempo médio de atendimento**: deve estar abaixo de 15 dias.
- **Taxa de conclusão no prazo**: meta de 100%.
- **Volume de solicitações por tipo**: identifica padrões e oportunidades de melhoria.
- **Taxa de indeferimento**: justificativas devem ser documentadas.
- **Satisfação do titular**: pesquisa pós-atendimento.

## Automação de respostas recorrentes

Para solicitações recorrentes — como confirmação de tratamento — automatize a resposta com templates aprovados pelo DPO e pelo jurídico, reduzindo o tempo de atendimento e garantindo consistência.

## Perguntas frequentes

### O que é necessário para implementar validação de CPF neste contexto?
A validação de CPF exige uma chamada à API com o número do documento e a chave de autenticação. A CPFHub.io retorna o status do CPF, nome do titular e data de nascimento em ~900ms, permitindo a verificação em tempo real durante o cadastro ou transação.

### A API CPFHub.io funciona para todos os volumes de consulta?
Sim. O plano gratuito oferece 50 consultas por mês sem cartão de crédito — ideal para testes e projetos pequenos. Para volumes maiores, o plano Pro inclui 1.000 consultas mensais por R$149. Se o limite for ultrapassado, a API não bloqueia: cobra R$0,15 por consulta adicional.

### Como garantir conformidade com a LGPD ao usar uma API de CPF?
Use o CPF apenas para a finalidade declarada ao titular, armazene apenas o necessário (não guarde o CPF cru se um token bastar), implemente controle de acesso aos logs de consulta e documente a base legal para o tratamento. A [ANPD](https://www.gov.br/anpd/) orienta que dados de identificação devem ser tratados com o princípio da necessidade.

### Quanto tempo leva para integrar a API CPFHub.io?
A integração básica leva menos de 30 minutos: crie uma conta em cpfhub.io, gere a API key no painel e faça uma chamada GET para `https://api.cpfhub.io/cpf/{CPF}` com o header `x-api-key`. A documentação inclui exemplos em Python, Node.js, PHP, Java e outras linguagens.

### Leia também

- [Diferença entre validação de CPF e consulta de CPF: quando usar cada uma](https://cpfhub.io/blog/diferenca-entre-validacao-de-cpf-e-consulta-de-cpf-quando-usar-cada-uma)
- [API de CPF grátis para desenvolvedores: como começar em 5 minutos](https://cpfhub.io/blog/api-cpf-gratis-desenvolvedores-comecar-5-minutos)
- [Onboarding digital em fintechs: como validar CPF em menos de 30 segundos](https://cpfhub.io/blog/onboarding-digital-em-fintechs-como-validar-cpf-em-menos-de-30-segundos)
- [KYC no Brasil: quais setores são obrigados a validar CPF por lei](https://cpfhub.io/blog/kyc-no-brasil-quais-setores-sao-obrigados-a-validar-cpf-por-lei)

---

## Conclusão

O atendimento aos direitos do titular é uma obrigação legal que, quando bem implementada, fortalece a relação de confiança com os clientes. Um sistema estruturado, com protocolos claros, prazos controlados e registros de auditoria, demonstra maturidade na governança de dados e reduz significativamente o risco de sanções por descumprimento.

Cadastre-se em [cpfhub.io](https://www.cpfhub.io/) — 50 consultas mensais gratuitas, sem cartão de crédito — e comece hoje mesmo.