Detection - Blindfold

What is Detection?

Detection is a read-only analysis method that identifies sensitive data in text without transforming it. The original text is not modified — you only receive a list of detected entities with their types, positions, and confidence scores. Example:

Input:  "Contact John Doe at john@example.com"
Output: [{type: "Person", text: "John Doe", start: 8, end: 16, score: 0.99},
         {type: "Email Address", text: "john@example.com", start: 20, end: 36, score: 0.98}]

How It Works

Detection: Blindfold identifies sensitive entities in your text
Report: Returns entity types, positions, confidence scores, and matched text
No transformation: The original text is not modified, masked, or returned

When to Use Detection

Detection is ideal when you need to:

1. Data Loss Prevention (DLP)

Monitor what sensitive data flows through your AI agents or applications.

# Check if user input contains sensitive data before processing
result = client.detect(user_input, policy="strict")

if result.entities_count > 0:
    log_violation(user_id, result.detected_entities)
    block_or_alert()

Why this matters:

Know what PII is flowing through your systems
Enforce data handling policies automatically
Create audit trails for compliance

2. Compliance Monitoring

Continuously scan data streams to detect policy violations.

# Scan customer support messages for HIPAA violations
result = client.detect(support_message, policy="hipaa_us")

critical_types = {"Social Security Number", "Medical Condition", "Medication"}
found_types = {e.type for e in result.detected_entities}

if found_types & critical_types:
    alert_compliance_team(found_types)

3. Data Auditing

Understand what PII exists in your datasets before processing.

# Audit a batch of records
for record in records:
    result = client.detect(record)
    for entity in result.detected_entities:
        audit_log.append({
            "type": entity.type,
            "confidence": entity.score
        })

4. Pre-Processing Checks

Decide which privacy method to apply based on what’s detected.

# Route to different processing based on detected PII
result = client.detect(text, policy="strict")

entity_types = {e.type for e in result.detected_entities}

if "Credit Card Number" in entity_types:
    # Mask credit cards
    processed = client.mask(text, policy="pci_dss")
elif "Social Security Number" in entity_types:
    # Redact SSNs completely
    processed = client.redact(text, policy="hipaa_us")
else:
    # Tokenize everything else
    processed = client.tokenize(text)

When NOT to Use Detection

Detection is not suitable when:

1. You Need to Transform the Text

If you need to remove, mask, or replace PII, use the appropriate method directly.

# Detection only tells you WHAT is there — it doesn't change anything
result = client.detect("SSN: 123-45-6789")
# result.detected_entities → [{type: "Social Security Number", ...}]
# But the text is unchanged!

# Use redact, mask, tokenize, etc. to actually transform
redacted = client.redact("SSN: 123-45-6789")

2. You Already Know You Want a Specific Method

If you know you want tokenization or redaction, call that method directly — it already returns detected entities in its response.

Key Features

Read-Only

Text is analyzed but never modified

Lightweight

No transformation overhead — fastest method

Policy Support

Use GDPR, HIPAA, PCI DSS, or custom policies

60+ Entity Types

Detects all supported PII types

Quick Start

Python
JavaScript
Java
cURL

from blindfold import Blindfold

client = Blindfold(api_key="your-api-key")

result = client.detect(
    "Patient Jane Smith (DOB: 1985-04-12, SSN: 123-45-6789) prescribed Metformin",
    policy="hipaa_us"
)

print(f"Found {result.entities_count} entities")

for entity in result.detected_entities:
    print(f"- {entity.type}: {entity.text} (confidence: {entity.score:.2f})")
# - Person: Jane Smith (confidence: 0.99)
# - Date of Birth: 1985-04-12 (confidence: 0.94)
# - Social Security Number: 123-45-6789 (confidence: 0.97)
# - Medication: Metformin (confidence: 0.99)

import { Blindfold } from '@blindfold/sdk';

const client = new Blindfold({ apiKey: 'your-api-key' });

const result = await client.detect(
  "Patient Jane Smith (DOB: 1985-04-12, SSN: 123-45-6789) prescribed Metformin",
  { policy: "hipaa_us" }
);

console.log(`Found ${result.entities_count} entities`);

result.detected_entities.forEach(entity => {
  console.log(`- ${entity.type}: ${entity.text} (confidence: ${entity.score.toFixed(2)})`);
});

import dev.blindfold.sdk.Blindfold;

Blindfold client = new Blindfold("your-api-key");

var result = client.detect(
    "Patient Jane Smith (DOB: 1985-04-12, SSN: 123-45-6789) prescribed Metformin"
);

System.out.println("Found " + result.getEntitiesCount() + " entities");

for (var entity : result.getDetectedEntities()) {
    System.out.printf("- %s: %s (confidence: %.2f)%n",
        entity.getType(), entity.getText(), entity.getScore());
}
// - Person: Jane Smith (confidence: 0.99)
// - Date of Birth: 1985-04-12 (confidence: 0.94)
// - Social Security Number: 123-45-6789 (confidence: 0.97)
// - Medication: Metformin (confidence: 0.99)

curl -X POST https://api.blindfold.dev/api/public/v1/detect \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Patient Jane Smith (DOB: 1985-04-12, SSN: 123-45-6789) prescribed Metformin",
    "policy": "hipaa_us"
  }'

# Response
{
  "entities_count": 4,
  "detected_entities": [
    {
      "type": "Person",
      "text": "Jane Smith",
      "start": 8,
      "end": 18,
      "score": 0.99
    },
    {
      "type": "Date of Birth",
      "text": "1985-04-12",
      "start": 25,
      "end": 35,
      "score": 0.94
    },
    {
      "type": "Social Security Number",
      "text": "123-45-6789",
      "start": 42,
      "end": 53,
      "score": 0.97
    },
    {
      "type": "Medication",
      "text": "Metformin",
      "start": 66,
      "end": 75,
      "score": 0.99
    }
  ]
}

Configuration Options

Filter Specific Entity Types

Only detect specific types of sensitive data:

result = client.detect(
    "John Doe (SSN: 123-45-6789) paid with card 4532-7562-9102-3456",
    entities=["social security number", "credit card number"]
)
# Only SSN and credit card entities returned

Adjust Confidence Threshold

Control detection sensitivity:

# Only high-confidence detections
result = client.detect(
    text="Maybe email: test@test",
    score_threshold=0.8
)

Common Patterns

DLP Agent Gate

Block sensitive data from reaching AI models:

def safe_ai_call(user_message: str) -> str:
    """Only send to AI if no critical PII detected"""
    scan = client.detect(user_message, policy="strict")

    critical = {"Social Security Number", "Credit Card Number"}
    found = {e.type for e in scan.detected_entities}

    if found & critical:
        return "I cannot process messages containing SSNs or credit card numbers."

    return call_ai_model(user_message)

Compliance Dashboard

Aggregate PII detection across your application:

def log_pii_detection(user_id: str, text: str) -> None:
    """Log PII detections for compliance reporting"""
    result = client.detect(text, policy="gdpr_eu")

    if result.entities_count > 0:
        compliance_db.insert({
            "user_id": user_id,
            "timestamp": datetime.utcnow(),
            "entity_types": [e.type for e in result.detected_entities],
            "entity_count": result.entities_count,
        })

Learn More

Python SDK

Full Python SDK documentation

JavaScript SDK

Complete JavaScript guide

Java SDK

Sync and async Java client

REST API

HTTP API reference for /detect

Examples

Practical integration examples

Compare with Other Methods

Tokenization

Reversible replacement (restore later)

Redaction

Permanent removal of PII

Masking

Partial visibility for users

Hashing

Consistent identifiers for tracking

Documentation Index

​What is Detection?

​How It Works

​When to Use Detection

​1. Data Loss Prevention (DLP)

​2. Compliance Monitoring

​3. Data Auditing

​4. Pre-Processing Checks

​When NOT to Use Detection

​1. You Need to Transform the Text

​2. You Already Know You Want a Specific Method

​Key Features