Reversible redaction lets you replace a sensitive value with a token, send the token somewhere less trusted, and turn it back into the value later. There are two broad ways to build it. Both are legitimate; they put the risk in different places.
Vault tokenization
A tokenization service issues a random token for each value and records the pair in a lookup table — the vault. To get the value back, you ask the service to look the token up.
What it does well
- The token is random, so it carries no information about the value.
- You can make a single value unrecoverable by deleting its row.
- It is a mature, widely deployed design, especially for payment data.
What it costs
- The vault is a second copy of every sensitive value you have ever tokenized. It has to be secured, replicated, backed up and audited like the primary data.
- Every restore depends on the vault being reachable, so it sits on the critical path of your application.
- It is a single, high-value target.
Map-free format-preserving encryption
Format-preserving encryption (FPE) encrypts a value into another value of the same shape: a sixteen-digit card becomes a different sixteen-digit card. The token is the ciphertext, so there is nothing to store — restoring means decrypting with the key. The standard method is FF1 from NIST SP 800-38G.
What it does well
- No table of originals exists anywhere. A breached database of tokens is a breached database of ciphertext.
- Restore needs only the key, not a reachable service holding the data.
- It is deterministic under one key, so the same value always produces the same token and joins still work on redacted data.
- Tokens keep their format, so downstream validators and schemas keep working.
What it costs
- The key becomes the thing to protect. Anyone with the key and a token can recover the value.
- You cannot revoke one value on its own; making tokens unrecoverable means retiring the key.
- Determinism means equal values are visibly equal. That is usually what you want for joins; it is a leak if equality itself is sensitive.
- Restore by key transforms anything that looks like a token. If a downstream system or a language model invents a new card number, restoring will turn it into a different number, so validate outputs you act on.
Side by side
| Vault tokenization | Map-free FPE | |
|---|---|---|
| Where the originals live | in the vault | nowhere — recoverable from token plus key |
| What you must protect | the vault and access to it | the key |
| What a restore depends on | the vault being online | the key being available |
| Revoking one value | delete its row | not possible without retiring the key |
| Token format | random, often format-preserving | same format as the value |
| Equal values | can be designed either way | always equal under one key |
Which to choose
Pick a vault when you need to revoke individual values, when tokens must reveal nothing about equality, or when you already run one and your controls are built around it.
Pick map-free FPE when the operational cost of a vault is the problem — for example when tokens flow through LLM calls, agents and third parties, and restoring happens inside your own services where the key is available.
Vaultless, FPE-based tokenization is not new; some enterprise vendors offer it as part of larger platforms. Obscate offers it as a self-serve API for text and JSON: strategy: "fpe" returns an empty token_map, and POST /v1/restore-fpe restores with the key alone. The hosted API processes values in memory for the duration of a request and does not store or log them. A self-hosted edition, where the key never leaves your network, is planned and not yet available.