Obscate

Reversible privacy infrastructure for AI and agent data exchange.

Obscate detects sensitive data in text and JSON and replaces it with tokens that are themselves the encrypted value — still format-valid for cards, Aadhaar, PAN and more — then restores the original on the way back. Your data, and your agents’, can pass through LLMs and third parties with no mapping database anywhere. Nothing stored, nothing to leak.

Your data4242 4242 4242 4242
FF1 · AES-256 · your key
What the model sees 7695 1067 6534 8610 ✓ Still passes Luhntoken_map: {}
same key, no lookup
What comes back 4242 4242 4242 4242 ✓ Exact
The token is the ciphertext. No database in the middle.
  • Map-free by design.NIST FF1 with AES-256 — no lookup table to breach.
  • Format-preserving.A redacted card still passes Luhn, so validation never breaks.
  • Hosted today. Self-hosted: comingLive: the hosted API, in Bangalore, retaining nothing. Self-hosted is not available yet — pilot list open.

Try it. No signup.

A real card becomes a different card that still passes Luhn — then comes back exactly.

Playground Connecting…

Redacted output
Detected entities 0
TypeOriginalReplacementCheck

How it works

No vault. No map. Nothing to breach.

A mapping database keeps every original next to its token — a second copy of your most sensitive data. Obscate encrypts each value in place with your key. Restore needs the key and nothing else.

The usual wayMapping-database tokenization
  1. Plain text4242 4242 4242 4242
  2. Tokenizerissues a random token
  3. Token vaulttok_8f3a… ↔ 4242 4242 4242 4242
    • A second copy of every sensitive value
    • Secured, replicated, backed up, audited
    • Every restore needs the vault online
  4. Detokenizerlooks the token up in the vault
  5. Original4242 4242 4242 4242
ObscateMap-free format-preserving encryption
  1. Plain text4242 4242 4242 4242
  2. FF1 · AES-256encrypt with your key
  3. Token = ciphertext7695 1067 6534 8610Luhn ✓
  4. LLM · tool · third partysees only the token
  5. FF1⁻¹ · same keydecrypt in place
  6. Original, exactly4242 4242 4242 4242

token_map: {} — nothing stored, nothing to look up.

01

Detect

Checksum validators (Luhn, Verhoeff, mod-97, GSTIN), patterns for structured IDs, spaCy NER for names and places.

02

Encrypt in place

FF1 encrypts each value, cycle-walking until the token is checksum-valid and the same type. Names become authenticated AES-SIV tokens like [PERSON:abc…].

03

Restore exactly

Tokens are re-detected and decrypted with the same key. Every fpe redaction self-checks the round trip before it returns.

Measured, not claimed

The numbers. And their limits.

1.00F1 on every structured and checksum ID type1
0.92Micro F1 across all entity types1
200/200Exact restores for fpe, tokenize and synthetic1
2.02 msMedian fpe round trip, engine time2

1 Synthetic benchmark: 200 documents, 484 labelled spans (python -m eval.benchmark). Structured IDs: cards, Aadhaar, GSTIN, IBAN, PAN, SSN, email, phone, IPv4, MAC. Clean synthetic input makes 1.00 an upper bound, not a real-world claim. Names and places are best-effort — Person 0.80, Location 0.77; an optional LLM tier is coming to hosted plans. 2 In-process on an Apple M5 laptop, 80-character documents — not API latency.

Why Obscate

Built for regulated data.

01

Map-free reversible redaction.

Some enterprise vendors offer vaultless FF1 behind a sales process. Here it’s one self-serve call: "strategy": "fpe".

  • Deterministic. Same value, same key, same token — joins and analytics still work.
  • Standards-based. NIST SP 800-38G FF1, AES-256, verified against all nine NIST sample vectors.

FF1, not FF3-1: NIST’s February 2025 draft of SP 800-38G Rev. 1 drops FF3 after an attack that also affects FF3-1.

POST /v1/redactstrategy: fpe
// request
{ "text": "Refund card 4242 4242 4242 4242", "strategy": "fpe" }

// response
{ "redacted":  "Refund card 7695 1067 6534 8610",
  "reversible": true,
  "token_map":  {} }

// later — key only, no map
POST /v1/restore-fpe  { "text": "…7695 1067 6534 8610" }
→ { "text": "Refund card 4242 4242 4242 4242" }
02

Tokens that still pass the checks.

Same format, valid checksum — so validators keep working and restore can find the tokens again.

TypeOriginal → fpe tokenCheck
Card4111 1111 1111 11110381 2360 4214 0458Luhn ✓
Aadhaar2341 2341 23464640 9059 9315Verhoeff ✓
IBANDE89 3704 0044 0532 0130 00DE76 7956 2030 9150 9630 27mod-97 ✓
GSTIN27AAPFU0939F1ZV50EXADI9119TBZDchecksum ✓
PANABCPS1234FNVRXH9291Lformat
Emailravi@example.comdsre@jkglndp.comTLD kept

Also SSN, phone, IPv4, MAC, AWS keys. Throwaway key; yours gives different tokens.

03

Text and JSON. Agents included.

Redact outbound, restore inbound. Keys and shape are kept; field names act as hints; restore returns the exact parsed values.

{ "customer": {
    "name":  "Priya Sharma",
    "email": "priya.sharma@example.com",
    "pan":   "ABCPS1234F" },
  "txn": { "card": "4242424242424242", "amount": 1299.5 } }
{ "customer": {
    "name":  "[PERSON:abc5zxah…]",
    "email": "djqbn.evlmjh@badbqyc.com",
    "pan":   "WLLZY0658C" },
  "txn": { "card": "7695106765348610", "amount": 1299.5 } }
04

Fluent in Aadhaar, PAN and GSTIN.

Aadhaar and GSTIN are validated by their own check digits, PAN by pattern — alongside every identifier a fintech handles.

  • Aadhaar Verhoeff
  • PAN
  • GSTIN checksum
  • Cards Luhn
  • IBAN mod-97
  • US SSN
  • Email
  • Phone
  • IPv4 / IPv6
  • MAC
  • AWS access keys
  • Person NER
  • Location NER

Allow- and deny-lists included.

05

Nothing stored. Nothing logged.

Everything a request leaves behind on the server:

# the entire log line for one /v1/redact call
2026-11-19 06:24:26,233 INFO rid=437516c03a00 POST /v1/redact 200 4ms
  • Errors never echo the request body. Enforced by automated privacy tests.
  • The hosted API holds plaintext in memory only while it handles a request.
06

Hosted today. Your VPC: coming.

For teams that need the trust boundary at their own network edge. Not available yet.

Hosted APILive now
  • Self-serve: an API key in one call
  • Processing and account data in Bangalore, India
  • Nothing retained; plaintext in memory only during a request
  • HMAC-hashed keys, per-key rate limits
Your systems⇄ TLS ⇄Obscate API
in memory, per request
Self-hosted, in your VPCComing · not yet available
  • Planned: detection and FPE inside your perimeter, under your key
  • Planned: same API and same tokens as hosted
  • Recruiting a small number of design-partner pilots
Your VPC
your systems ⇄ Obscate
Request a pilot

For banks and fintechs

Built for the security review. Not around it.

What security and compliance ask first. Live and planned, clearly marked.

Self-hosted, in your VPC

Not available yet. Planned: detection and encryption inside your network, under your key, with the same API and tokens as hosted.

Coming · recruiting design-partner pilots

Security model

Live: no retention of inputs, values or maps; logs carry request metadata only; keys stored as HMAC hashes.

Read the security overview

Data residency

Live: processing and account data in Bangalore, India; no customer content at rest. Traffic enters through Cloudflare’s edge network.

DPDP Act and GDPR

Designed to help you meet DPDP Act obligations such as data minimisation and purpose limitation, and GDPR’s equivalents. A tool for your programme, not a certification of it.

Join the self-hosted pilot list, ask about volume pricing, or walk your security team through the design.

Request a pilot

Pricing

Pay to protect. Restore is free.

Every account starts on Free — no card, no sales call.

Free

$0

  • 1,000 requests / month
  • 60 requests / minute
  • Hard cap — no overage charges
  • All six strategies, text and JSON
Get an API key

Starter

$49/month

  • 100,000 requests / month
  • Then $1 per 1,000
  • 300 requests / minute
  • Everything in Free
Start on Free

Growth

$299/month

  • 1,000,000 requests / month
  • Then $0.50 per 1,000
  • 600 requests / minute
  • Optional LLM tier — coming to hosted plans
Start on Free

Enterprise

Custom

  • Custom volume and rate limits
  • Self-hosted / in-VPC — coming (pilot list open)
  • Security review support
Talk to us

A request is one call, text or JSON, up to 100 KB (larger bodies count ⌈size ÷ 100 KB⌉; 1 MB max; batches count per item). Only successful calls are metered; restore is free.

Billing isn’t live yet: paid plans are enabled on request.

Full pricing, metering and rate limits

For developers

Three calls. A safe LLM round trip.

  1. Get a key. POST /v1/signup with your email. Shown once; we keep only its HMAC.
  2. Redact. POST /v1/redact with "strategy": "fpe". Send the result to any model or tool.
  3. Restore. POST /v1/restore-fpe with the model’s reply. Key only, no map.

JSON: /v1/redact-json and /v1/restore-json.

Quickstart   Full API reference

# 1. Get a key (shown once)
curl -s API/v1/signup \
  -H 'content-type: application/json' \
  -d '{"email":"you@company.com"}'

export OBSCATE_API_KEY=ob_...

# 2. Redact — map-free
curl -s API/v1/redact \
  -H "x-api-key: $OBSCATE_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"text":"Refund card 4242 4242 4242 4242 for priya.sharma@example.com","strategy":"fpe"}'
# → {"redacted":"Refund card 1629 6367 0545 2530 for usnvr.fuhhub@spkqrkv.com","token_map":{},…}
#   (tokens depend on your key)

# 3. Restore — the key is all you need
curl -s API/v1/restore-fpe \
  -H "x-api-key: $OBSCATE_API_KEY" \
  -H 'content-type: application/json' \
  -d '{"text":"<the model reply containing tokens>"}'

Security

Stated precisely.

Controls in place today

  • No logging or storage of inputs, values or maps
  • Errors never echo bodies; no tracebacks
  • Keys stored as HMAC hashes, shown once
  • Auth and rate limits before the body is read
  • Per-key rate limits; 1 MB max body
  • Keys from the environment; production won’t start without them

Cryptography

  • FF1 with AES-256, tested against all nine NIST vectors
  • One key → HKDF-SHA256 → separate FF1 and AES-SIV subkeys
  • Authenticated AES-SIV tokens for names, so restore never “decrypts” text that isn’t a genuine token
  • Property tests: restore(redact(t)) == t; no strategy outputs a full raw value

Limits, stated plainly

  • The hosted API sees plaintext in memory during a request. “Never leaves your perimeter” will only be true with self-hosted, which is not available yet.
  • If an LLM invents a new card or email that looks like a token, key-only restore transforms it too. Names and places are immune.
  • Name and place detection is best-effort (~0.80 recall on our synthetic benchmark).
  • No SOC 2 or ISO 27001 certification yet. Compliance work is in progress.

Read the full security overview

Protect the payload. Keep the answer.

Free tier, 1,000 requests a month, no card.

Get a free API key

Free plan: 1,000 requests a month, all strategies. Your key is shown once — we store only a hash of it.

Prefer the terminal?
curl -s API/v1/signup \
  -H 'content-type: application/json' \
  -d '{"email":"you@company.com"}'

Contact

Our contact address is being set up.