Skip to main content
logssanitizer

Runs entirely in your browser

Online logs sanitizer Share the log, not the secrets.

Paste a log file and every credential, token, and personal detail is swapped for a consistent stand-in — so it still reads like a log, still groups by user, and carries nothing you would not put in a public issue.

  • No upload, no account
  • 53 detectors
  • Reads JSON, logfmt & Syslog
  • Checksum-validated matches
Replacement style
Redacts by field name in JSON and logfmt, so a sensitive key is caught even when its value looks ordinary.Catches random-looking secrets that match no known format, at some risk of false positives.Re-runs as you type. Switch it off for very large logs and use Sanitize instead.Each value becomes a realistic stand-in of the same shape, so the log still groups and diffs.Each value becomes a plain tag like [EMAIL_1]: easy to skim, but you cannot correlate lines.

Original Log

Plain text
Empty

Cleaned

Output appears here once there is something to clean.

Nothing scanned yet
Choose What To Hide
Credentials & tokens
Cloud provider keys
Payment & financial
Personal data
Network addresses
Infrastructure names
IDs & traces
Filesystem paths
Custom Rules & Allowlist0

Your Own Patterns

Add internal service names, tenant slugs, or a regex of your own. Rules stay in this browser. Export them before clearing site data or moving to another machine.

Match

    No custom rules yet.

    Never Redact

    Values here are always left visible. Use it to stop over-redaction of things that are safe and useful, like loopback addresses or your own public hostnames. One value per line.

    Surrogate Consistency

    A secret salt stored in this browser makes replacements repeatable, so the same email becomes the same stand-in across every file you clean. Share the salt with a teammate to get matching output; rotate it to break the link with everything you have cleaned before.

    A sanitized log should still be a useful log.

    Most log data masking works by numbering. Replace every address with[IP_1],[IP_2],[IP_3] and you have protected the data while destroying the thing you needed it for. You can no longer tell that forty of those lines came from the same client.

    Here the same value always becomes the same stand-in, and the stand-in keeps the shape of what it replaced. Group by user, count distinct addresses, diff two runs — it all still works. Only genuine secrets collapse to a label, because correlating on a password has no value and ambiguity there is a hazard.

    Same address, twice, two approaches

    Labels only

    login  [IP_1]
    retry  [IP_2]
    retry  [IP_3]

    Three unrelated clients, apparently.

    Shape preserved

    login  198.51.100.24
    retry  198.51.100.24
    retry  198.51.100.24

    One client retrying. That was the bug.

    How to sanitize a log file in three steps

    1. 01

      Drop In The Raw Log

      Paste text or drag a .log, .txt, or .json file straight onto the editor. It never leaves the tab.

    2. 02

      Dial In The Pass

      Pick a preset, slide the sensitivity, and add any patterns specific to your stack. Results update as you type.

    3. 03

      Check, Then Hand It Off

      Review the diff and the mapping table, then copy the output or export a receipt of what was removed.

    What the log sanitizer looks for

    53 detectors across eight categories, each one switchable. Sensitive data filtering is only worth having if it is accurate, so matches are confirmed with checksums and entropy scoring rather than shape alone, and a separate entropy pass catches secrets that have no recognisable prefix.

    See All 53 Detectors

    Common jobs, and what happens to the values

    Strip IP addresses from logs
    IPv4 and IPv6 addresses become stable stand-ins from reserved documentation ranges, so a client that retried forty times still looks like one client.
    Remove passwords from logs
    Password assignments and credentials embedded in connection URLs collapse to a plain label. Nobody correlates on a password, so shape is not worth keeping.
    Mask bearer tokens in logs
    Authorization headers, JSON Web Tokens, and cookie headers are replaced whole — a JWT only after its header is decoded and an alg claim is confirmed.
    Redact AWS keys from log output
    Access key IDs, secret access keys, ARNs, and account IDs are matched on structure, alongside keys for GitHub, GitLab, Stripe, Slack, Google, OpenAI, and Azure.
    Hide secrets in log files that match no known format
    The entropy pass scores random-looking strings on their own merits, which catches homegrown tokens that carry no recognisable prefix.
    Sanitize log files for a public issue
    The Public issue preset strips infrastructure topology as well as secrets and personal data: internal hostnames, Kubernetes resources, and broker endpoints.

    Redact logs before sending them to an AI assistant

    A prompt is not a scratchpad. Paste a raw log into ChatGPT, Claude, or Copilot and it becomes part of a conversation you cannot selectively delete, on infrastructure you do not control, under a retention policy that changes with your plan. If a live API key was sitting in that log, it is now sitting in a chat history.

    Removing the sensitive data before you prompt is the obvious fix — but removing it badly makes the assistant useless. Turn every address and identifier into[IP_1] and[USER_2] and the model can no longer see that one client failed nine times in a row, which was the thing you were asking about. Format-preserving replacements keep those relationships intact, so the model reasons about the real pattern while the real values stay with you. TheShare with an AI assistant preset applies that pass in one click.

    A client-side log sanitizer — don’t trust the claim, check the header.

    Every browser-based log scrubber says nothing is uploaded. This one is built so the browser enforces it: the production page ships a Content-Security-Policy that forbids network connections outright. If this page tried to send your log somewhere, the browser would refuse.

    Response header, in productionVerifiable
    Content-Security-Policy:
      default-src 'self';
      script-src 'self' 'sha256-fd1KHxdN3ScLs/fjr4c9f+ZQPyEGnSmKzr7vbt9puXo=';
      style-src 'self' 'unsafe-inline';
      img-src 'self' data:;
      font-src 'self';
      worker-src 'self' blob:;
      connect-src 'none';
      form-action 'none';
      base-uri 'none';
      object-src 'none';
      frame-src 'none';
      frame-ancestors 'none';
      manifest-src 'self';
      upgrade-insecure-requests;

    Assistants keep context

    A chat holds whatever you feed it, for as long as that conversation exists. Clean the log before it becomes part of one.

    Tickets outlive the incident

    Once a log lands in an issue or a support thread it gets copied, indexed, and archived far longer than you intended.

    Cleaning is not an undo

    Any real credential that reached a log should be rotated at the source. Redacting the copy does nothing about the original exposure.

    Frequently asked questions

    Is it safe to sanitize logs for ChatGPT or another AI assistant?

    That is one of the main reasons this exists. Because the sanitizing happens in your browser, the log never reaches a third party in raw form — you paste the cleaned output into the assistant instead. Use the “Share with an AI assistant” preset, which is deliberately aggressive: it assumes the log is about to become part of a conversation you cannot delete. Read the output before you send it, because no automated pass understands your data as well as you do.

    What exactly does it remove — passwords, bearer tokens, AWS keys, IP addresses?

    All of those, out of 53 detectors in total. Password assignments and credentials embedded in URLs collapse to a clear label. Bearer and Basic authorization headers, JSON Web Tokens, PEM private keys, and provider keys — AWS access keys, Google API keys, GitHub and GitLab tokens, Stripe keys, Slack tokens, OpenAI and Anthropic keys, Azure storage keys — are matched on their prefixes and structure. IP addresses, MAC addresses, and hostnames are swapped for stable stand-ins from reserved documentation ranges rather than deleted, so traffic patterns survive. Emails, phone numbers, payment card numbers, IBANs, and national identifiers such as US Social Security numbers are treated as personal data. Every detector can be switched off individually.

    Is my log uploaded anywhere?

    No. Detection and replacement run inside your browser, in a Web Worker. In production the page also ships a Content-Security-Policy containing connect-src 'none', which means the browser itself blocks this page from making any network request at all. You can verify that in your developer tools.

    What does “format-preserving” mean?

    Most redaction tools turn every email into [EMAIL_1] and every address into [IP_2], which destroys your ability to group events. This tool replaces an email with a stable fake email, an IP with a stable address from a reserved documentation range, and a UUID with a stable fake UUID. The same input always maps to the same stand-in, so you can still count, group, and diff. Secrets are the exception: those always become clear labels, because nobody correlates on a password.

    Can two different values collide onto the same replacement?

    No. Replacements are allocated through a table that detects a collision and deterministically picks the next candidate, so two distinct originals never merge into one stand-in.

    How does it avoid redacting things that are not secrets?

    Three ways. Card numbers are checked with the Luhn algorithm and IBANs with mod-97, so ordinary long digit runs are left alone. JSON Web Tokens are confirmed by decoding the header and checking for an alg claim. And when the log is structured, keys are read directly, so authorization is always redacted while token_type stays visible.

    Does it handle structured logs?

    Yes. JSON, JSON Lines, and logfmt are parsed so redaction can follow field names rather than guessing from value shapes. Syslog and Common Log Format are recognised and still scanned by every pattern detector.

    Is the default enough for GDPR or a public issue?

    Not on its own. At the Balanced default, internal identifiers such as user_id, tenant_id, trace_id, and Kubernetes pod names are left readable, because redacting them usually makes a log useless for the debugging you needed it for. Those identifiers can still re-identify a person when combined with other data, so switch to the GDPR preset, the Public issue preset, or simply raise the sensitivity when that matters.

    Do my settings and custom rules persist?

    They are saved in this browser only. Export your rules before you clear site data or move to another machine.

    Why is there a salt, and should I share it?

    The salt makes replacements repeatable, so the same value maps to the same stand-in across every file you clean. Share it with a teammate when you both need matching output for the same incident. Rotate it to break the link with everything you cleaned before.

    A real credential appeared in my log. Is cleaning it enough?

    No. Treat it as compromised and rotate it at the source. A cleaned copy protects the copy you are about to share; it does nothing about the original exposure.