AI-nativesensitive-dataclassification

Given free text, structured data, images, or documents,it discovers sensitive data (PII) and classifies each document with confidence scores.

Book a demo
Multi-signal fusionPII discoveryDocumentclassificationMath validationFree-text understandingCalibrated confidenceFeedback loopEvidence traceability
46
sensitive data categories
8
sensitive document-type categories
93%
structured-data Macro F1
90%
free-text Macro F1 (core types)
  • GDPR
  • China PIPL
  • CCPA/CPRA
  • India DPDP
  • Japan APPI
  • Singapore PDPA
  • Brazil LGPD
  • SOC 2
  • ISO 27701
  • HIPAA
  • PCI DSS
  • GLBA

Precise verdicts, reliable traceability

Multi-signal cross-verification

Context signals (column names, field paths, nearby text) fuse stage by stage with a multilingual semantic analysis model, producing traceable verdicts.

  • Multilingual semantic analysis model trained on 1M+ real samples, Chinese, English, and other languages
  • Column names, field paths, and surrounding text all feed the decision
  • Results can show their evidence: candidates, fused scores, rejection reasons

Deterministic checksum proof

For types with check digits, deterministic math settles authenticity: fabricated card, account, ID, and device numbers simply fail validation.

  • 30+ country ID formats, 20+ country tax IDs, 6 card brands
  • Mock/test-data detection keeps drills out of your statistics
  • Obviously irrelevant content is filtered out automatically, keeping detection focused on real sensitive data

Confidence means probability

Per-type confidence calibration makes 0.87 mean “87% likely correct”. High-confidence results return directly; low-confidence results are automatically flagged for review rather than guesses.

  • Chinese is calibrated separately, so its confidence scores are equally reliable
  • Idempotent output: same input, same verdict, auditable and replayable

Continuous evolution on real traffic

Review verdicts flow back encrypted as training corpus, with regression guards. The system keeps improving with real usage.

  • Training corpus stored encrypted locally, used for training only after authorization
  • Per-category accuracy and health observable in the console

Efficient sensitive-document recognition

  • Financial

    Financial reports, annual reports, prospectuses, audit reports

    High sensitivity

  • Legal contracts

    Commercial contracts, agreements, legal instruments

    High sensitivity

  • Medical records

    Clinical records, discharge summaries, examination reports

    High sensitivity

  • Source code

    Program source files

    Code asset

  • Internal documents

    Internal reports, memos, process documents

    High sensitivity

  • HR records

    Résumés, compensation and performance files, employee rosters

    High sensitivity

  • Credentials & secrets

    Passwords and API keys, private keys and connection strings

    Block & rotate

  • Patents

    Patent specifications, claims, patent application drafts

    High sensitivity

Plug-and-play REST API

curl -X POST https://databrain.example.com/v1/text/scan \
  -H 'Content-Type: application/json' \
  -d '{
    "text": "Customer daniel.wu@google.com, phone +1-415-555-0142.",
    "min_confidence": 0.5
  }'
import requests

text = "Customer daniel.wu@google.com, phone +1-415-555-0142."
resp = requests.post(
    "https://databrain.example.com/v1/text/scan",
    json={"text": text, "min_confidence": 0.5},
    timeout=30,
)
for m in resp.json()["results"]:
    print(m["pii_type"], m["confidence"])
const resp = await fetch("https://databrain.example.com/v1/text/scan", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "Customer daniel.wu@google.com, phone +1-415-555-0142.",
    min_confidence: 0.5,
  }),
})
for (const m of (await resp.json()).results)
  console.log(m.pii_type, m.confidence)
curl -X POST https://databrain.example.com/v1/values/scan \
  -H 'Content-Type: application/json' \
  -d '{
    "values": [
      {"value": "daniel.wu@google.com", "label_hint": "email"},
      {"value": "110101199003077334", "label_hint": "id_card"}
    ]
  }'
import requests

values = [
    {"value": "daniel.wu@google.com", "label_hint": "email"},
    {"value": "110101199003077334", "label_hint": "id_card"},
]
resp = requests.post("https://databrain.example.com/v1/values/scan",
                     json={"values": values}, timeout=30)
for r in resp.json()["results"]:
    print(r["pii_type"], r["confidence"])
const values = [
  { value: "daniel.wu@google.com", label_hint: "email" },
  { value: "110101199003077334", label_hint: "id_card" },
]
const resp = await fetch("https://databrain.example.com/v1/values/scan", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ values }),
})
for (const r of (await resp.json()).results)
  console.log(r.pii_type, r.confidence)
curl -X POST https://databrain.example.com/v1/image/scan \
  -H 'Content-Type: application/json' \
  -d "{\"image_base64\": \"$(base64 -w0 invoice.png)\"}"
import base64, requests

with open("invoice.png", "rb") as f:
    img_b64 = base64.b64encode(f.read()).decode()

resp = requests.post("https://databrain.example.com/v1/image/scan",
                     json={"image_base64": img_b64}, timeout=30)
for m in resp.json()["results"]:
    print(m["pii_type"], m["value"])
import { readFileSync } from "node:fs"

const image_base64 = readFileSync("invoice.png").toString("base64")
const resp = await fetch("https://databrain.example.com/v1/image/scan", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ image_base64 }),
})
for (const m of (await resp.json()).results)
  console.log(m.pii_type, m.value)
curl -X POST https://databrain.example.com/v1/document \
  -H 'Content-Type: application/json' \
  -d '{
    "text": "'"$(cat contract.txt)"'",
    "options": {"want_genre": true}
  }'
import requests, pathlib

text = pathlib.Path("contract.txt").read_text(encoding="utf-8")
resp = requests.post("https://databrain.example.com/v1/document",
                     json={"text": text, "options": {"want_genre": True}},
                     timeout=120)
doc = resp.json()
print(doc["genre"], doc["genre_confidence"])
import { readFileSync } from "node:fs"

const text = readFileSync("contract.txt", "utf8")
const resp = await fetch("https://databrain.example.com/v1/document", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ text, options: { want_genre: true } }),
})
const doc = await resp.json()
console.log(doc.genre, doc.genre_confidence)

Data sovereignty and privacy protection

Fully offline

No telemetry, no callbacks, no external model calls; inference is local and runs air-gapped.

Masked by default

Detection logs mask values by default, keeping type and confidence; scanned content is not persisted.

Signed delivery

Signed installation packages with offline licensing, revocable.

Least privilege

Non-root container; training corpus stored encrypted locally, used for training only after authorization.

Run it once in your own environment. Give it a try. Open integration.

Book a demo