privatiser.net

Privatiser's Settings panel gives you four levers to tune detection: Custom words to redact (always redacted, regardless of pattern), Allowlist (never redacted), Custom regex patterns (with a case-insensitive toggle), and Saved presets (save, load, delete, export, import). All of this runs locally in your browser — the site states "Local processing only — nothing leaves your machine," so your rules and the text they touch stay on your machine.

Where these controls live

Open the Settings tab (the tool has Try it / Anonymize / Deanonymize / Settings views). The relevant fields are:

Alongside these, the built-in Detection categories (Secrets & Keys, Network, PII, AWS Cloud, Generic Identifiers) and Pattern packs (Crypto, Kubernetes, Terraform, Comms, Location & Coordinates) stay on unless you turn them off — your custom rules layer on top of them.

Force-redact terms with Custom words

Use this when a value matters to you but no built-in pattern would catch it — internal project codenames, a hostname that doesn't match the Network rules, a customer name.

1. Go to Settings.
2. In Custom words to redact, enter the terms separated by commas, e.g. ProjectFalcon, acme-internal, ticket-4471.
3. Return to Anonymize and paste your text.

Expected result: every listed term is replaced in the anonymized output and recorded in the mapping, so Deanonymize restores it. Because the rule is unconditional, a term here is redacted even if it would otherwise look harmless.

Stop false positives with the Allowlist

Use this when a pattern is over-matching something you need to keep readable — a public company name that trips the Names rule, a documentation IP like 192.0.2.1, a sample card number in a tutorial.

1. In Settings, find Allowlist (never redact).
2. Enter the values separated by commas.
3. Re-run Anonymize on the same text.

Expected result: those values pass through untouched while everything else is still redacted. The allowlist wins over detection, so it's the right tool for "this looks sensitive but isn't."

A practical ordering note: if a value appears in both lists, treat the allowlist as your safety net and keep the two lists disjoint to avoid guessing which rule applies.

Add your own patterns with Custom regex

Use this for structured identifiers your organization uses that aren't in the built-in set — an internal ID format, a ticket prefix, a proprietary token shape.

1. In Settings, open the Custom regex patterns area and choose the identifier type it belongs to (Identifiers, Secrets, PII, or Network) via Add pattern.
2. Enter the regular expression.
3. Enable Case insensitive if the format varies in casing.
4. Test against a sample in Anonymize and confirm the match count and the mapping entry.

Expected result: matches are redacted like any built-in pattern and appear in the mapping JSON. Keep patterns anchored and specific — a loose expression will redact far more than intended, and the allowlist is your correction path if it does.

Save, reuse, and move your configuration

Once the rules fit your workflow:

• Save current stores the configuration as a preset; Load reapplies it; Delete removes it.
• Export all and Import move your full configuration between browsers or machines.

This matters because the tool is also available as a browser extension (Chrome, Firefox), a VS Code extension, and a Python package (pip install privatiser) — a preset you export from the web tool is the portable record of your rules.

Common snags

• Comma-separated means commas are separators. A term containing a comma can't be entered as a single custom word this way.
• Custom words are unconditional. If you add something to the redact list and later want it visible, remove it there rather than expecting the allowlist to override it.
• Regex is the highest-risk control. Add one pattern at a time and verify the match count before adding the next.
• Presets are your rollback. Save a known-good preset before experimenting with regex so you can reload it if detection goes wrong.

Quick decision guide

Privatiser is a browser-based tool that strips sensitive values from text before you paste it into an AI chat, then lets you restore the real values from a local mapping afterward. It detects 30+ patterns across 13 languages, covering secrets and keys, network and cloud identifiers, and personal identity data. Everything runs locally in your browser — the site states "nothing leaves your machine" and "0 bytes to any server," so the redaction happens on your device rather than on a remote service.

Secrets and keys

These are the credentials that most often leak by accident when developers paste config or logs into an AI assistant:

• API keys and secrets — including provider-prefixed keys such as sk-proj-... (OpenAI-style) and generic assignments like DB_PASSWORD = "..." or webhook_secret = "...".
• JWTs and bearer tokens — the eyJ... header-payload-signature strings, plus Bearer tokens.
• SSH / PEM keys — private key blocks.
• Slack tokens — e.g. xoxb-....
• Generic identifiers — passwords written in English, French, or Spanish (mot_de_passe, contraseña), which the sample input shows being caught.

Network and cloud identifiers

Useful when you're debugging infrastructure and want to share a config without exposing your topology:

• IP addresses — both public and internal ranges (e.g. 10.0.4.221, 192.168.1.100).
• Internal domains — hostnames like monitoring.local:9090.
• MAC addresses.
• Cloud resource IDs — AWS ARNs (arn:aws:iam::...), plus AWS, GCP, and Azure identifiers, and Azure-style resource paths such as /subscriptions/0000-4000-a000-0001/prod.

Personal identity data (PII)

For text that contains customer or personal records:

• Emails and phone numbers (including international formats like +44 ...).
• Credit cards — validated with the Luhn check, so random 16-digit strings aren't flagged by mistake.
• SSNs, passports, IBANs — e.g. 078-05-1120, A1234567, GB29 NWBK ....
• Vehicle plates and VINs.
• Names and dates of birth.
• UK-specific identifiers — NHS numbers, SWIFT codes, sort codes.

Optional pattern packs and custom rules

Beyond the built-in categories, you can enable extra pattern packs for domain-specific work:

You can also add custom regex patterns (with a case-insensitive option) and a custom words to redact list for anything not covered by a pack. A separate allowlist lets you mark values that should never be redacted, so you don't accidentally strip something you need to keep.

How to check it fits your case

1. Open the live tool on the site and paste a representative sample of the text you'd normally share with an AI.
2. Confirm the values you care about appear in the redacted output. If a pattern is missing, add it under Custom regex patterns or Custom words to redact.
3. Note that detection is pattern-based, not semantic — it catches structured formats (keys, IPs, card numbers) reliably, but free-form names or unusual formats may need a custom rule.
4. If you want the same behavior without copy-pasting, the browser extension auto-anonymizes on paste into ChatGPT, Claude, Gemini, and others; there's also a VS Code extension and a Python package (pip install privatiser).

The practical takeaway: if your sensitive data is structured — credentials, network addresses, cloud IDs, or standard PII formats — Privatiser's built-in patterns will likely cover it. If it's unstructured or domain-specific, plan on adding custom regex or a word list.

Privatiser runs entirely in your browser or local environment — nothing is sent to a server — and it ships in four delivery forms: a live web tool, a browser extension for Chrome and Firefox, a VS Code extension, and a Python package installed via pip install privatiser. Pick the web tool if you want to paste text manually and control exactly what gets redacted; pick the browser extension if you want anonymization to happen automatically the moment you paste into an AI chat; pick the VS Code extension if your sensitive text lives in code; pick the Python package if you want to script the process. All four share the same detection engine and the same reversible mapping model.

How the shared workflow works

Every entry point follows the same two-step loop, which is what makes the mapping portable across surfaces:

1. Anonymize — paste or select text, and Privatiser replaces detected values with pseudonyms while keeping the surrounding structure intact.
2. Deanonymize — paste the AI's reply back in, and the real values snap back using the local mapping.

The mapping is the key artifact. It's what makes the process reversible, and it stays on your machine. You can copy it as JSON, download it, or load it back from a file — so a mapping generated in one tool can be reused in another.

The four ways to use it

Web tool (live, in-browser)

The live tool is the most manual and the most controllable option. You paste text into an input pane and get a redacted copy plus a local mapping.

What you get that the other surfaces don't expose as directly:

• Detection categories you can toggle — Secrets & Keys, Network (IPs, Domains), PII (Phone, Cards), AWS Cloud (Azure, GCP), and Generic Identifiers.
• Pattern packs — Crypto (BTC, ETH, keys), Kubernetes, Terraform, Comms (Slack, Teams, Twilio), and Location & Coordinates.
• Custom words to redact — a comma-separated list that is always redacted regardless of pattern.
• Allowlist (never redact) — a comma-separated list of values that will never be redacted, useful for keeping placeholder values or public identifiers intact.
• Custom regex patterns — with a case-insensitive toggle, so you can add your own identifiers, secrets, PII, or network patterns.
• Redact selection — redact only the highlighted portion rather than the whole input.
• Saved presets — save, load, delete, export all, or import your configuration.

You also get Copy JSON and Download for the mapping, and Copy / Download for the output text. If you want to reuse a previous result, Use last output and Use last mapping are available, and you can Load from file for a mapping.

Choose this when you want to inspect and tune exactly what gets caught before sharing anything.

Browser extension (Chrome and Firefox)

The browser extension auto-anonymizes on paste into ChatGPT, Claude, Gemini, and other AI tools. It's the lowest-friction option: you don't change your workflow, you just paste as normal and the redaction happens on the way in.

• Chrome — available as a Chrome extension.
• Firefox — available as a Firefox add-on, with the same auto-anonymize behavior.

Choose this if your main risk is habitually pasting raw text into a chat window and you want protection without thinking about it. The trade-off is that you're not hand-picking categories per paste the way you can in the web tool.

VS Code extension

The VS Code extension anonymizes selections without leaving the editor. You highlight code or config, run the anonymize action, and get a redacted version you can paste elsewhere.

Choose this when the sensitive material is already in your editor — connection strings, .env values, cloud identifiers — and you'd rather not round-trip through a browser tab.

Python package

Install with:

pip install privatiser

Choose this if you want to anonymize as part of a script, pipeline, or batch process rather than interactively. It's the option for repeatable, programmatic use.

What all four surfaces detect

The detection coverage is shared, so this list applies regardless of which entry point you pick:

The engine covers 30+ patterns across 13 languages, and the source description states it is an open-source engine. The page also lists an example set that includes passwords (DB_PASSWORD, mot_de_passe, contraseña), phone numbers, and card numbers — so the practical scope is "anything you'd regret pasting into a chat box."

Which one should you pick?

These aren't mutually exclusive. A common pattern is to use the browser extension for day-to-day chat use and the web tool when you need finer control — and because the mapping is exportable and loadable from a file, you can move a mapping between them.

Practical notes before you start

• Nothing leaves your machine. The page states local processing only and "0 bytes to any server." That's the core reason to use any of these surfaces over pasting raw text.
• Structure is preserved. Redaction replaces values without collapsing the surrounding format, so the AI still sees usable context.
• Reversibility depends on the mapping. If you lose the mapping, you can't restore the original values. Export or download it if the session matters.
• Custom words always win. Anything in the "Custom words to redact" list is redacted regardless of whether a pattern matched it — useful for internal project names or hostnames that no generic pattern would catch.
• The allowlist is your safety valve. If a pattern is over-matching something you need to keep (a public domain, a placeholder), add it to the allowlist rather than disabling the whole category.

Start with the surface that matches where your text already is. If you're unsure, the web tool is the most transparent place to see what gets caught before you commit to automating it.

Privatiser replaces sensitive values in text you paste into it with stand-in tokens, produces a redacted copy plus a local mapping, and runs the whole process in your browser — the site states "0 bytes to any server" and "Local processing only — nothing leaves your machine." You then paste the AI's reply back into the Deanonymize view, and the real values are restored from that mapping. This works for any workflow where you want to send text to an AI tool without exposing secrets, credentials, or personal data.

What happens when you anonymize

The tool scans pasted text against a set of built-in detection patterns and swaps each match for a pseudonym, keeping the surrounding structure intact. The page lists 30+ patterns across 13 languages, and the detection categories include:

• Secrets & keys — API keys, JWTs and bearer tokens, SSH/PEM keys, generic secrets
• Network — IPs, internal domains, MAC addresses
• PII — emails, phone numbers, credit cards (Luhn-checked), SSNs, passports, IBANs, names, dates of birth
• Cloud identifiers — AWS, GCP, and Azure IDs
• Pattern packs — crypto (BTC, ETH, keys), Kubernetes, Terraform, comms (Slack, Teams, Twilio), location and coordinates

The example text on the site shows this in practice: values like DB_PASSWORD = "super_s3cr3t_passw0rd!", 10.0.4.221:5432, AKIAIOSFODNN7EXAMPLE, a postgres://admin:... connection string, and a sk-proj-... key are all candidates for replacement.

You can narrow or widen what gets caught:

• Custom words to redact — comma-separated values that are always redacted regardless of pattern
• Allowlist — comma-separated values that are never redacted
• Custom regex patterns — with a case-insensitive toggle, grouped under Identifiers, Secrets, PII, or Network

The output pane shows a redacted count and gives you Copy and Download actions, plus a separate Mapping panel with Copy JSON and Download.

What the mapping is for

Anonymizing alone would make the AI's answer useless, because it would refer to tokens instead of your real values. The mapping is the bridge: it records which pseudonym stands for which original value, and it stays on your machine.

You can manage it in a few ways:

• Copy the mapping as JSON
• Download it to a file
• Load it back from a file later
• Save, load, and delete named presets, or export and import all of them

Because the mapping is a file you control, you can keep it for a session, store it for a recurring workflow, or discard it once you're done.

How deanonymization works

1. Paste your text into the input area and run Anonymize. You get a redacted copy.
2. Send the redacted copy to your AI tool of choice.
3. Paste the AI's reply into the Deanonymize view.
4. The tool applies the mapping and returns the restored output, which you can copy.

The Deanonymize view offers Use last output and Use last mapping so you don't have to re-paste either one, and Load from file if you saved the mapping earlier. The site's own summary of the loop: "Paste in, get a redacted copy plus a local mapping — paste the AI's reply back into Deanonymize and every real value snaps back."

Where it runs

The processing is client-side. The site states "Local processing only — nothing leaves your machine" and "0 bytes to any server," and describes the engine as open source. That matters because the alternative — pasting credentials into a hosted redaction service — would move the exposure rather than remove it.

The same engine is available outside the browser tab:

• Browser extension — auto-anonymizes on paste into ChatGPT, Claude, Gemini and others (Chrome; a Firefox add-on offers the same behavior)
• VS Code extension — anonymize selections without leaving the editor
• Python package — pip install privatiser

Practical caveats

• Detection is pattern-based, so review the output. The coverage list is broad, but anything that doesn't match a pattern, a custom word, or a custom regex will pass through. The custom words and custom regex fields exist precisely for values your data has that the built-in patterns don't know about.
• The allowlist cuts both ways. A value on the allowlist is never redacted, so don't put anything there that you actually need hidden.
• Keep the mapping private. It contains the original values by definition. Treat a downloaded mapping file the same way you'd treat the source text.
• Deanonymization depends on the mapping. If you anonymize in one place and try to restore in another without the mapping, the tokens stay tokens. Use the JSON copy, the downloaded file, or the saved preset to carry it across.

The site's navigation lists a Pricing section, but the supplied page content doesn't state any prices, plan limits, or whether a login is required, so check the site directly for current terms.

Privatiser is a browser-based tool that strips sensitive data out of text before you paste it into an AI chatbot. It detects things like API keys, passwords, IP addresses, and personal identifiers, replaces them with pseudonyms, and keeps a local mapping so you can restore the real values later. Everything runs in your browser — the site states that nothing leaves your machine and that it sends 0 bytes to any server.

It fits a specific situation: you want an AI to help with a config file, a log snippet, a database connection string, or a support ticket, but the text contains secrets or personal data you can't share. Privatiser lets you hand over the useful structure without the sensitive values.

How the anonymize-and-restore loop works

The workflow has two halves, and the second is what makes it usable for real tasks:

1. Anonymize — paste text into the input. Privatiser detects matching patterns and replaces each one with a pseudonym. You get a redacted copy plus a local mapping (shown as a mapping count, with options to copy or download the JSON).
2. Send the redacted text to the AI — the structure is preserved, so the model can still reason about your config, code, or data shape.
3. Deanonymize — paste the AI's reply back into the Deanonymize panel. Using the last mapping (or loading one from a file), every pseudonym snaps back to its real value.

The mapping is the key mechanism: it's what separates this from simply deleting sensitive text. Because the mapping stays local, the reversibility doesn't require sending anything anywhere.

What it detects

The tool advertises 30+ patterns across 13 languages. From the detection categories and examples on the page:

Optional pattern packs extend coverage to Crypto (BTC, ETH, keys), Kubernetes, Terraform, Comms (Slack, Teams, Twilio), and Location & Coordinates.

Controls that matter in practice

• Custom words to redact — a comma-separated list that is always redacted regardless of pattern, useful for project names or internal codenames.
• Allowlist — values that should never be redacted, so common words or public identifiers don't get masked by mistake.
• Custom regex patterns — add your own detection rules, with a case-insensitive option.
• Saved presets — save, load, delete, export, and import your configuration.
• Redact selection — anonymize only a highlighted portion rather than the whole input.

Where you can run it

• Live tool in the browser (the primary interface).
• Browser extension — auto-anonymizes on paste into ChatGPT, Claude, Gemini and others; available for Chrome and as a Firefox add-on.
• VS Code extension — anonymize selections without leaving the editor.
• Python package — pip install privatiser.

When it's the right choice — and when it isn't

Privatiser is a good fit if your main concern is pasting sensitive text into a hosted AI service and you want a reversible, structure-preserving redaction that never uploads your data. The local-processing claim is the central selling point, and the deanonymize step means you don't lose the ability to map the AI's answer back onto real values.

It's less suited if you need server-side auditing, team-shared mappings, or centralized policy enforcement — the design is deliberately local and single-machine. The page also doesn't state pricing beyond a "PRO" label on the settings panel and a "Pricing" link, so check the site directly for what's free versus paid before relying on it for a workflow.