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.
What the model sees7695 1067 6534 8610✓ Still passes Luhntoken_map: {}
same key, no lookup
What comes back4242 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.
PlaygroundConnecting…
Redacted output
✓Restored
Detected entities 0
Type
Original
Replacement
Check
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
Plain text4242 4242 4242 4242
Tokenizerissues a random token
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
Detokenizerlooks the token up in the vault
Original4242 4242 4242 4242
ObscateMap-free format-preserving encryption
Plain text4242 4242 4242 4242
FF1 · AES-256encrypt with your key
Token = ciphertext7695 1067 6534 8610Luhn ✓
LLM · tool · third partysees only the token
FF1⁻¹ · same keydecrypt in place
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.
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.
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.
# 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>"}'
import os, requests
API = "API"
H = {"x-api-key": os.environ["OBSCATE_API_KEY"]}
# Redact before the prompt leaves your system
r = requests.post(f"{API}/v1/redact", headers=H, json={
"text": "Refund card 4242 4242 4242 4242 for priya.sharma@example.com",
"strategy": "fpe",
}).json()
assert r["token_map"] == {} # nothing to store
reply = call_your_llm(r["redacted"]) # model sees tokens only# Restore the real values in the reply — key only
restored = requests.post(f"{API}/v1/restore-fpe", headers=H,
json={"text": reply}).json()["text"]
const API = "API";
const headers = {
"x-api-key": process.env.OBSCATE_API_KEY,
"content-type": "application/json",
};
const post = (path, body) =>
fetch(API + path, { method: "POST", headers, body: JSON.stringify(body) })
.then((res) => res.json());
// Redact before the prompt leaves your systemconst r = await post("/v1/redact", {
text: "Refund card 4242 4242 4242 4242 for priya.sharma@example.com",
strategy: "fpe",
});
// r.token_map is {} — nothing to storeconst reply = await callYourLLM(r.redacted); // model sees tokens only// Restore the real values — key onlyconst { text } = await post("/v1/restore-fpe", { text: reply });
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.