Português

English

Português

English

Tema Escuro

Anonimização de Texto ​

A funcionalidade de Anonimização de Texto do SipPulse AI é uma ferramenta poderosa projetada para identificar e redigir (mascarar ou substituir) informações sensíveis de qualquer conteúdo textual. Este recurso é crucial para organizações que manuseiam dados pessoais e necessitam aderir a regulamentações de privacidade de dados como GDPR, HIPAA, LGPD, entre outras.

Através de reconhecimento avançado de padrões e configurações flexíveis, você pode proteger dados confidenciais antes de armazená-los, processá-los ou compartilhá-los.

Playground Interativo ​

O Playground de Anonimização de Texto (acesse aqui) oferece uma interface intuitiva para experimentar e validar as capacidades de anonimização em tempo real:

  • Seleção de Idioma: Escolha o idioma do texto a ser processado. A seleção do idioma influencia as entidades de dados sensíveis disponíveis para anonimização.
  • Entrada de Texto: Insira ou cole o texto que deseja anonimizar.
  • Seleção de Entidades: Marque as entidades específicas que devem ser detectadas e redigidas (e.g., CPF, Email, Nome). As entidades disponíveis são adaptadas conforme o idioma selecionado.
  • Configuração de Sequência Numérica: Para a entidade "Número", defina o comprimento mínimo da sequência de dígitos a ser considerada para anonimização (e.g., anonimizar apenas números com 3 ou mais dígitos).
  • Regras de Pesquisa e Substituição (Search and Replace):
    • Defina padrões de texto específicos (literais ou expressões regulares básicas, dependendo da implementação do Playground) para localizar no texto.
    • Especifique o texto de substituição para cada padrão encontrado.
    • Adicione múltiplas regras para cenários de anonimização complexos ou personalizados.
  • Processamento e Visualização: Clique para anonimizar e veja o resultado redigido instantaneamente, permitindo ajustes rápidos nas configurações.
  • Geração de Código: Obtenha exemplos de código em cURL, Python e JavaScript, pré-configurados com os parâmetros utilizados no Playground, facilitando a integração da API.

O Playground é uma ferramenta essencial para entender o comportamento do motor de anonimização, testar diferentes configurações e preparar a integração em suas aplicações.

Entidades de Anonimização por Idioma ​

O motor de anonimização suporta diferentes conjuntos de entidades detectáveis dependendo do idioma do texto.

Português (pt) ​

As seguintes entidades podem ser anonimizadas em textos em português:

  • EMAIL: Endereços de e-mail (e.g., usuario@dominio.com → [EMAIL])
  • URL: Endereços web e links (e.g., https://site.com.br → [URL])
  • CNPJ: Cadastro Nacional da Pessoa Jurídica (e.g., 00.000.000/0001-00 → [CNPJ])
  • CPF: Cadastro de Pessoas Físicas (e.g., 123.456.789-00 → [CPF])
  • PERSON: Nomes de pessoas (e.g., João da Silva → [PERSON])
  • CREDIT_CARD_NUMBER: Números de cartão de crédito (e.g., 4111111111111111 → [CREDIT_CARD_NUMBER])
  • DATE_TIME: Datas e horários (e.g., 14/05/2025 10:30 → [DATE_TIME])
  • LOCATION: Nomes de lugares, cidades, estados, países (e.g., São Paulo → [LOCATION])
  • IP_ADDRESS: Endereços de Protocolo de Internet (e.g., 192.168.0.1 → [IP_ADDRESS])
  • NUMBER: Sequências numéricas, configurável por comprimento (parâmetro sequence).

Inglês (en) ​

As seguintes entidades podem ser anonimizadas em textos em inglês:

  • EMAIL_ADDRESS: Endereços de e-mail (e.g., user@domain.com → [EMAIL_ADDRESS])
  • URL: Endereços web e links (e.g., https://website.com → [URL])
  • US_SSN: Número de Seguridade Social dos EUA (e.g., 000-00-0000 → [US_SSN])
  • CREDIT_CARD_NUMBER: Números de cartão de crédito (e.g., 4111111111111111 → [CREDIT_CARD_NUMBER])
  • PERSON: Nomes de pessoas (e.g., John Doe → [PERSON])
  • DATE_TIME: Datas e horários (e.g., May 14, 2025 10:30 AM → [DATE_TIME])
  • LOCATION: Nomes de lugares, cidades, estados, países (e.g., New York → [LOCATION])
  • IP_ADDRESS: Endereços de Protocolo de Internet (e.g., 192.168.0.1 → [IP_ADDRESS])
  • NUMBER: Sequências numéricas, configurável por comprimento (parâmetro sequence).

Para obter a lista exata e atualizada de entidades suportadas por um idioma específico, utilize o endpoint da API /v1/anonymize/entities/{language}.

Consumo via API REST ​

Integre a anonimização de texto diretamente em suas aplicações e fluxos de trabalho.

Listar Entidades Disponíveis por Idioma ​

Para consultar as entidades de anonimização que podem ser detectadas para um idioma específico:

Endpoint: GET /v1/anonymize/entities/{language}

Parâmetro de Caminho:

  • language (string, obrigatório): O código do idioma (e.g., pt, en, es).
bash
# Exemplo para obter entidades para o idioma Português
curl -X GET 'https://api.sippulse.ai/v1/anonymize/entities/pt' \
  -H 'api-key: $SIPPULSE_API_KEY' \
  -H 'Accept: application/json'
python
import os
import requests
import json

def get_anonymization_entities(language: str, api_key: str) -> list | None:
    """Busca as entidades de anonimização disponíveis para um idioma."""
    url = f"https://api.sippulse.ai/v1/anonymize/entities/{language}"
    headers = {"api-key": api_key, "Accept": "application/json"}
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.HTTPError as e:
        print(f"Erro na API: {e.response.status_code} - {e.response.text}")
    except Exception as e:
        print(f"Ocorreu um erro: {e}")
    return None

if __name__ == "__main__":
    api_key = os.getenv("SIPPULSE_API_KEY")
    if api_key:
        entities_pt = get_anonymization_entities("pt", api_key)
        if entities_pt:
            print("Entidades para Português (pt):")
            print(json.dumps(entities_pt, indent=2, ensure_ascii=False))
        
        entities_en = get_anonymization_entities("en", api_key)
        if entities_en:
            print("\nEntidades para Inglês (en):")
            print(json.dumps(entities_en, indent=2, ensure_ascii=False))
    else:
        print("Erro: Variável de ambiente SIPPULSE_API_KEY não configurada.")
javascript
// Node.js com fetch
async function getAnonymizationEntities(language, apiKey) {
  const url = `https://api.sippulse.ai/v1/anonymize/entities/${language}`;
  const headers = { "api-key": apiKey, "Accept": "application/json" };
  try {
    const response = await fetch(url, { headers });
    if (!response.ok) {
      throw new Error(`Erro na API: ${response.status} - ${await response.text()}`);
    }
    return await response.json();
  } catch (error) {
    console.error(`Falha ao buscar entidades para ${language}:`, error);
    return null;
  }
}

// Exemplo de uso:
// (async () => {
//   const apiKey = process.env.SIPPULSE_API_KEY;
//   if (apiKey) {
//     const entitiesPt = await getAnonymizationEntities("pt", apiKey);
//     if (entitiesPt) console.log("Entidades PT:", JSON.stringify(entitiesPt, null, 2));
//     const entitiesEn = await getAnonymizationEntities("en", apiKey);
//     if (entitiesEn) console.log("Entidades EN:", JSON.stringify(entitiesEn, null, 2));
//   } else {
//     console.error("SIPPULSE_API_KEY não configurada.");
//   }
// })();

Exemplo de Resposta (JSON para pt):

json
[
  "EMAIL",
  "URL",
  "CNPJ",
  "CPF",
  "PERSON",
  "CREDIT_CARD_NUMBER",
  "DATE_TIME",
  "LOCATION",
  "IP_ADDRESS",
  "NUMBER"
]

Anonimizar Texto ​

Para realizar a anonimização de um bloco de texto:

Endpoint: POST /v1/anonymize

Corpo da Requisição (JSON):

json
{
  "text": "string", // Obrigatório: O texto a ser anonimizado.
  "entities": ["string"], // Obrigatório: Lista das entidades a serem detectadas e redigidas. Use as strings retornadas pelo endpoint /entities/{language}.
  "sequence": 0, // Opcional, padrão 0: Para a entidade "NUMBER", define o comprimento mínimo da sequência de dígitos para anonimização. Se 0 ou não fornecido, a anonimização de números pode usar um padrão ou ser desativada se "NUMBER" não estiver em 'entities'. Se > 0, apenas números com 'sequence' ou mais dígitos são anonimizados.
  "language": "string", // Obrigatório: Código do idioma do texto (e.g., "pt", "en").
  "search_and_replace": [ // Opcional: Lista de regras de pesquisa e substituição.
    {
      "search": "string", // Padrão de texto a ser procurado.
      "replace": "string", // Texto de substituição.
      "case_sensitive": true // Booleano, opcional, padrão true: Define se a busca é sensível a maiúsculas/minúsculas.
    }
  ]
}

Resposta (JSON):

  • Sucesso (200 OK):
    json
    {
  "text": "string" // O texto com as informações sensíveis redigidas.
}
  • Erro: Resposta JSON com código de status HTTP apropriado e detalhes do erro.
bash
# Exemplo de anonimização em Português
curl -X POST 'https://api.sippulse.ai/v1/anonymize' \
  -H 'api-key: $SIPPULSE_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "text": "Contato: João Silva, email joao.silva@exemplo.com.br, CPF 111.222.333-44. Telefone comercial 99999-1234 e código do cliente ABC001.",
    "entities": ["PERSON", "EMAIL", "CPF", "NUMBER"],
    "sequence": 5,
    "language": "pt",
    "search_and_replace": [
      {
        "search": "ABC001",
        "replace": "[COD_CLIENTE]",
        "case_sensitive": true
      }
    ]
  }'
python
import os
import requests
import json

def redact_text(
    text: str,
    entities: list,
    language: str,
    api_key: str,
    sequence: int = 0,
    search_and_replace_rules: list = None
) -> dict | None: # A resposta da API é {"text": "string"}
    """Realiza a anonimização de texto usando a API SipPulse AI."""
    url = "https://api.sippulse.ai/v1/anonymize"
    headers = {"api-key": api_key, "Content-Type": "application/json"}
    payload = {
        "text": text,
        "entities": entities,
        "language": language,
        "sequence": sequence
    }
    if search_and_replace_rules:
        payload["search_and_replace"] = search_and_replace_rules
    
    try:
        response = requests.post(url, headers=headers, data=json.dumps(payload))
        response.raise_for_status()
        return response.json() # Retorna {"text": "anonimizado..."}
    except requests.exceptions.HTTPError as e:
        print(f"Erro na API: {e.response.status_code} - {e.response.text}")
    except Exception as e:
        print(f"Ocorreu um erro: {e}")
    return None

if __name__ == "__main__":
    api_key = os.getenv("SIPPULSE_API_KEY")
    if not api_key:
        print("Erro: SIPPULSE_API_KEY não configurada.")
    else:
        sample_text_pt = "Meu nome é Maria Oliveira, email maria.oliveira@teste.com e meu CPF é 987.654.321-00. O pedido número 87654 será entregue."
        entities_to_redact = ["PERSON", "EMAIL", "CPF", "NUMBER"]
        # Anonimizar números com 5 ou mais dígitos
        # Adicionar uma regra de substituição personalizada
        custom_rules = [
            {"search": "pedido número", "replace": "protocolo", "case_sensitive": False}
        ]

        redacted_result = redact_text(
            text=sample_text_pt,
            entities=entities_to_redact,
            language="pt",
            api_key=api_key,
            sequence=5,
            search_and_replace_rules=custom_rules
        )

        if redacted_result:
            print("--- Texto Anonimizado ---")
            print(redacted_result.get("text")) # Acessa a chave "text" do JSON retornado
            # Informações como entities_found e usage não estão presentes na resposta simplificada
            # print("\n--- Entidades Encontradas ---")
            # if redacted_result.get("entities_found"):
            #     for entity in redacted_result["entities_found"]:
            #         print(f"- Tipo: {entity['type']}, Texto: \"{entity['text']}\"")
            # print(f"\nUso: {redacted_result.get('usage')}")
javascript
// Node.js com fetch
async function redactText({
  text,
  entities,
  language,
  apiKey,
  sequence = 0,
  searchAndReplaceRules = [],
}) { // A resposta da API é {text: string}
  const url = "https://api.sippulse.ai/v1/anonymize";
  const headers = { "api-key": apiKey, "Content-Type": "application/json" };
  const payload = {
    text,
    entities,
    language,
    sequence,
    search_and_replace: searchAndReplaceRules,
  };

  try {
    const response = await fetch(url, {
      method: "POST",
      headers,
      body: JSON.stringify(payload),
    });
    if (!response.ok) {
      throw new Error(`Erro na API: ${response.status} - ${await response.text()}`);
    }
    return await response.json(); // Retorna {text: "anonimizado..."}
  } catch (error) {
    console.error("Falha ao anonimizar texto:", error);
    return null;
  }
}

// Exemplo de uso:
// (async () => {
//   const apiKey = process.env.SIPPULSE_API_KEY;
//   if (!apiKey) {
//     console.error("SIPPULSE_API_KEY não configurada.");
//     return;
//   }
//   const result = await redactText({
//     text: "Contact John Doe at john.doe@example.com or call 555-0100. SSN: 000-00-1234.",
//     entities: ["PERSON", "EMAIL_ADDRESS", "US_SSN", "NUMBER"],
//     language: "en",
//     apiKey,
//     sequence: 7, // Anonimizar números com 7+ dígitos (ex: telefone)
//     searchAndReplaceRules: [{ search: "Contact", replace: "Reach out to", case_sensitive: false }]
//   });
//   if (result && result.text) { // Verifica se result e result.text existem
//     console.log("Texto Anonimizado:", result.text);
//   } else if (result) {
//     console.log("Resultado:", result); // Caso a estrutura seja diferente inesperadamente
//   }
// })();

Boas Práticas ​

  • Seja Específico com Entidades: Selecione apenas as entidades que são verdadeiramente sensíveis para o seu caso de uso para evitar a redação excessiva de informações úteis.
  • Teste a Configuração de Sequência Numérica: Ajuste o parâmetro sequence para a entidade "NUMBER" cuidadosamente. Um valor muito baixo pode redigir números irrelevantes, enquanto um valor muito alto pode deixar números sensíveis expostos.
  • Use search_and_replace com Cuidado: Embora poderoso, o search_and_replace baseado em strings literais ou regex simples deve ser testado exaustivamente para evitar substituições indesejadas. Considere a sensibilidade a maiúsculas/minúsculas (case_sensitive).
  • Monitore o Uso: Acompanhe o uso e os custos associados ao serviço de anonimização através do seu dashboard SipPulse AI.
  • Combine com Outras Medidas de Segurança: A anonimização de texto é uma camada de proteção. Combine-a com outras práticas de segurança de dados, como controle de acesso, criptografia e políticas de retenção de dados.

Perguntas Frequentes (FAQ) ​

A anonimização é reversível?

Não. O processo de anonimização substitui os dados sensíveis por placeholders (e.g., [CPF], [EMAIL]) ou pelo texto definido nas regras de search_and_replace. O SipPulse AI não armazena os dados originais de forma a permitir a reversão da anonimização via API.

Como a anonimização de "NUMBER" com sequence funciona?

Se você incluir "NUMBER" na lista de entities e definir sequence para, por exemplo, 3, o sistema procurará por sequências de três ou mais dígitos consecutivos e as substituirá por um placeholder como [NUMBER]. Números com menos de sequence dígitos não serão afetados por esta regra específica.