The reversible privacy layer for AI agents

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.

  • Map-free by design — the token is the ciphertext (NIST FF1), so there’s no lookup table to breach.
  • Format-preserving — a redacted card still passes Luhn; downstream validation never breaks.
  • Built for your VPC — with no central store, Obscate can run inside your perimeter. Self-hosted edition planned; we’re recruiting design-partner pilots.
Playground Connecting…

Redacted output
Detected entities 0
TypeOriginalReplacementCheck

How it works

The token is the ciphertext.
There is no database in the middle.

Reversible redaction usually means a mapping database: every original value stored next to its token so it can be looked up later. That vault is a second copy of your most sensitive data. Obscate’s fpe strategy encrypts each value in place with your key, so restoring needs the key and nothing else.

Typical approachMapping-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
    • Must be secured, replicated, backed up and audited
    • Every restore is a lookup that needs the vault online
  4. Tokentok_8f3a91c2
  5. Detokenizerlooks the token up in the vault
  6. 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.

1

Detect

Checksum validators (Luhn, Verhoeff, mod-97, GSTIN), patterns for structured IDs, and spaCy NER for names and places. Context words like “card” or “aadhaar” raise confidence.

2

Encrypt in place

Each value is parsed into a template — separators, prefixes, per-position alphabets — then FF1-encrypted and cycle-walked until the token is checksum-valid and detected as the same type. Names and other free text become authenticated AES-SIV tokens like [PERSON:abc…].

3

Restore exactly

On the way back, tokens are re-detected and decrypted with the same key. Every fpe redaction self-checks that restore returns the exact input before it is returned to you.

Why Obscate

Seven things that matter when the data is regulated.

01

Map-free reversible redaction

Most reversible tokenization keeps a vault of originals. Some enterprise vendors offer vaultless FF1 tokenization behind a sales process. Obscate makes it a self-serve API call: strategy: "fpe" returns an empty token_map, and restore needs only the key.

  • Nothing to store or ship around — no map in your database, your logs, or your queue.
  • Deterministic — the same value encrypts to the same token under the same key, so joins and analytics still work on redacted data.
  • Standards-based — NIST SP 800-38G FF1 with AES-256, verified against all nine official NIST FF1 sample vectors.

Why FF1 and not FF3-1: NIST’s February 2025 draft revision (SP 800-38G Rev. 1, 2nd public draft) drops FF3 after a published 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

Format- and checksum-preserving

A redacted card is still a valid-looking card; a redacted Aadhaar still passes Verhoeff. Downstream validators, schemas and parsers keep working — and the tokens can be found again for restore.

TypeOriginalfpe 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
AWS keyAKIAIOSFODNN7EXAMPLEAKIA61O6CYWGB4PG1LI6prefix kept

Also SSN, phone, IPv4 and MAC. Cards 13–19 digits. Outputs from one run with a throwaway key; your key gives different tokens.

03

Text and structured JSON

The guardrail for agent-to-agent payloads: redact outbound, restore inbound. /v1/redact-json keeps keys and shape, uses field names as hints, and /v1/restore-json 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

India-native, globally useful

Aadhaar, PAN and GSTIN are first-class detectors — Aadhaar and GSTIN validated by their own check digits — alongside the identifiers every 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-lists and deny-lists let you never redact your own public addresses, and always redact bespoke identifiers.

05

Nothing stored. Nothing logged.

Obscate never stores or logs your input, the values it detects, or the restore map. This is what a request leaves behind on the server — the complete log line:

# server log — the entire line for one /v1/redact call
2026-11-19 06:24:26,233 INFO rid=437516c03a00 POST /v1/redact 200 4ms
  • Error responses never echo the request body; unexpected errors log only the exception type.
  • Enforced by automated privacy tests on both success and error paths.
  • The hosted API processes plaintext in memory for the duration of a request. If data must never leave your perimeter, see self-hosted below.
06

Hosted API today. Inside your VPC for design partners.

Banks and regulated fintechs often need the trust boundary drawn at their own network edge. Obscate’s detection and encryption are deterministic and keyed, so they can run entirely inside your environment.

Hosted APIAvailable now
  • Self-serve signup, API key in one call
  • Inputs, detected values and maps are never stored or logged
  • Plaintext exists in memory only while your request is processed
  • Per-key rate limits; API keys stored only as HMAC hashes
Your systems⇄ TLS ⇄Obscate API
in memory, per request
Self-hosted, in your VPCDesign-partner pilots
  • Detection and FPE run inside your perimeter
  • Your key never reaches Obscate; your data never leaves your network
  • Same API and same tokens as hosted
  • Planned — we are looking for a small number of pilot partners
Your VPC
your systems ⇄ Obscate
Request a pilot
07

Benchmarked, with the limits stated

0.92micro F1, all entity types
1.00F1 on every structured / checksum ID
Structured IDs (10 types)1.00
Person0.80
Location0.77

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 — use deny-lists for known names; an optional LLM tier is coming to hosted plans. Exact restores: 200/200 for fpe, tokenize and synthetic. fpe round trip: 2.02 ms median engine time on 80-character documents (Apple M5, in-process) — not API latency.

Methodology and full results →

For banks & fintechs

Built for the security review, not around it.

What your security, risk and compliance teams will ask first — answered without hedging. Where something is planned rather than shipped, we say so.

Self-hosted, in your VPC

Detection and format-preserving encryption run inside your network, under your key. Your data and your key never reach Obscate. Same API, same tokens as hosted.

Planned · design-partner pilots

Security model

We never store or log your input, the detected values, or the restore map. Logs hold request id, method, path, status and latency only. API keys are stored as HMAC hashes. With fpe there is no map to hold at all.

Read the security overview →

Data residency

The hosted API runs in Bangalore, India, and keeps no customer content at rest. Account data (email, plan, usage, hashed keys) lives in a managed Postgres database, also in Bangalore. Traffic enters through Cloudflare’s edge network. Self-hosted (planned) keeps processing in your own region by construction.

DPDP Act & GDPR

Designed to help you meet DPDP Act obligations such as data minimisation and purpose limitation: send models and vendors only what they need, and keep identifiers recoverable only by you. The same applies to GDPR. Obscate is a tool for your programme, not a certification of it.

Request a pilotSelf-hosted pilot, volume pricing, or a walkthrough of the design with your security team.
Request a pilot

Pricing

Developer pricing. Restore is free.

You pay to protect a payload; restoring it is included. 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
  • All six strategies, text and JSON
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 — design-partner pilots
  • Security review support
Talk to us

What’s a request? One call — text or JSON — up to 100 KB. Larger bodies count as ⌈size ÷ 100 KB⌉; 1 MB maximum. Batches count at least one per item. Only successful requests are metered. Redact and detect are billed; restore is free.

Billing status. Card billing is being connected. Until it is live, paid plans are enabled on request.

For developers

Three calls to a safe LLM round-trip.

  1. Get a key. POST /v1/signup with your email. The key is shown once; we store 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.

For JSON payloads use /v1/redact-json and /v1/restore-json. Responses carry x-ratelimit-* headers.

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, for your security review.

Controls in place today

  • No logging or storage of inputs, detected values, or token maps — server logs hold request id, method, path, status and latency only
  • Error responses never echo request bodies; tracebacks are never printed
  • API keys stored only as HMAC hashes; shown to you once
  • Requests authenticated and rate-limited before the body is processed
  • Per-key rate limits; 1 MB maximum request body
  • Encryption keys read from the environment, never from code; production refuses to start without them

Cryptography

  • NIST SP 800-38G FF1 with AES-256, tested against all nine NIST FF1 sample vectors
  • One key → HKDF-SHA256 → separate FF1 and AES-SIV subkeys
  • Names and free text: authenticated AES-SIV tokens, so restore never “decrypts” text that isn’t a genuine token
  • Property-based tests: restore(redact(t)) == t, and no strategy ever outputs a full raw value

Limits, stated plainly

  • The hosted API sees plaintext in memory during a request. “Never leaves your perimeter” is true only for self-hosted (pilot stage).
  • If an LLM invents a new card or email that looks like a token, key-only restore will transform it too. Names and places are immune (authenticated tokens).
  • 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; we will walk your team through the design.

Try it on your own payloads.

Free tier, 1,000 requests a month, no card. Or talk to us about a self-hosted pilot.

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 and will be published here before launch. In the meantime you can try the API on the free plan.