Skip to content
Sign inRequest access

PII redaction

Redaction is a trust-boundary safeguard. It exists because the widget takes a picture of whatever is on screen and, on a project set to Technical capture, records the page’s console, requests and click trail, any of which can incidentally contain personal data. (A project on Normal capture records none of that technical text — only the screenshot, marks, notes, page address and device.) Most of redaction is off until you switch it on: on a project nobody has configured, the screenshot is rendered over the values as typed and, in Technical mode, the console text is forwarded as captured. What every project gets unconditionally is the query-parameter blanking on every URL we capture.

Everything that is switched on runs in the page, before the report leaves the browser, so a value it masks never reaches uMarker at all — and, equally, a value it does not mask arrives here exactly as captured. It is a best-effort safeguard layered on top of the review step the reporter already gets, not a DLP engine, and it is explicitly not a server-side cleanup pass. The masking happens on the device.

Typed values in the screenshot

With redaction switched on, every input and textarea value on the page is masked before the screenshot is rendered, so the pixels never contain the typed text. With it off — the default — the screenshot is rendered over the values as typed. Non-value input types (checkbox, radio, button, submit, hidden, range, color) are skipped. Rich-text (contenteditable) fields, whose value lives in their text content, are masked too.

Regions you mark yourself

With redaction switched on, any element matching a CSS selector the project lists as always-sensitive is masked when the screenshot is taken, whatever kind of element it is. The snippet uses the element’s value if it has one and its text content otherwise; the extension masks the text either way. The list is read only while that switch is on — it is not a control of its own.

Secrets in the captured text

With redaction switched on, secret-shaped strings in the technical text a Technical-mode report carries — console logs, breadcrumbs, request URLs, error messages — are replaced with [redacted] before the payload is sent: email addresses, phone numbers, labelled keys, long opaque tokens, and card-shaped digit groups. The snippet and the browser extension run the same pass, from the same widget engine.

Secret-named query parameters

In the request list a Technical-mode report carries, and in the page address every report carries, the value of a parameter whose name suggests a credential is blanked before the entry is buffered, so the raw value is never held in memory. The snippet and the extension do the same — on every project, either way.

This one runs on every project, switch or no switch, and it is the control most likely to matter: a 401 on /api/session?access_token=abc123 used to ship that token into the dashboard and onward into whatever tracker or Slack channel the project routes to.

The parameter’s name is what decides, matched against token, key, secret, password, passwd, pwd, auth, session, sid, sig, signature, otp, code, email and phone. Names are split on camelCase before the test, so sessionId and accessToken are caught the same way session_id and access_token are.

Only the named values go: ?page=2 is frequently why a request failed, and a failed-request list that can’t say which page is not worth capturing.

The blanking is one function, applied at every place a URL is captured: the failed-request buffer, the page URL and referrer sent with the report, and a CSP or Reporting-API blocked URL written into the console buffer. The snippet and the extension carry the same function, and a guard runs all copies against one table of addresses so they cannot drift. It is deliberately not left to the text patterns below, which match a label only at a word boundary: ?token=abc123 would be caught there, while ?access_token=, ?api_key= and ?sessionId= would not — the very names this rule exists to catch.

Text redaction is pattern-based and errs toward over-masking (a false positive is visible to the reporter in the review step; a miss is a leak). The built-in patterns are:

widget/v1.js: redactText()
/[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}/g // email addresses
/(?:\+|\b00)[1-9]\d{0,2}(?:[ .-]?\d){7,12}\b/g // international phone numbers
/\b05\d(?:[ .-]?\d){7}\b/g // Saudi mobile numbers
/\b(?:sk|pk|api|key|token|bearer|secret)[ _\-=][A-Za-z0-9_-]{6,}\b/gi // labelled keys
/\b[A-Za-z0-9_-]{32,}\b/g // long opaque tokens
/\b(?:\d[ -]?){13,16}\b/g // card-shaped digit groups

Each match becomes the literal string [redacted]. Detection is a heuristic, not a guarantee that every secret is caught. Treat a missed value as a defect to fix by adding a pattern, not as a reason to turn masking off.

With Auto-redact sensitive fields on, masking is applied to the live DOM before the screenshot is rendered, then reverted, so the host page is never left with masked values:

  1. Mask. Just before rendering, the widget walks the document (and any same-origin iframes, which the screenshot library also renders). input and textarea values are overwritten through the field’s own value property; rich-text (contenteditable) fields, and listed selectors with no value of their own, are masked by writing their text nodes with bullet characters. Each original is recorded so it can be put back.

  2. Render. The screenshot is produced from the now-masked DOM, so the typed values are never in the image bytes.

  3. Restore. The originals are written back, so the customer’s page is untouched, and the restore still runs even if rendering throws. Cross-origin iframes throw on access and are skipped rather than blocking the capture.

  4. Redact text. As the payload is assembled for a Technical-mode project, console log lines, breadcrumb labels and URLs, and request URLs are passed through the secret patterns. Only then is the report POSTed.

Section titled “Breadcrumbs record identifiers, not values”

Breadcrumbs — the trail of recent clicks and page/route changes — are recorded only on a project set to Technical capture, on the snippet and the extension alike; a Normal-mode project records none. Where they are recorded, they are built to avoid capturing personal data in the first place, not just to redact it afterwards:

  • An input breadcrumb records the field’s identifier (its name, id, aria-label or placeholder, or failing those its tag name), never the value typed into it.
  • A click breadcrumb records a stable CSS selector plus curated labels (aria-label / title), which the secret-pattern pass still scrubs.
  • A route breadcrumb records the path only; the query string, which can carry tokens, is dropped entirely.

Pattern matching won’t know that a particular element on your page always holds something private. For that, list always-sensitive selectors per project. The list is delivered to the widget in its config payload and evaluated client-side.

  • #ssn: a specific field by id
  • .card-number: everything with that class
  • [data-private]: an attribute you add to sensitive regions

Client-side redaction is the privacy control; the server adds a second, independent bound so a tampered or oversized payload can’t get around the project’s configuration. On ingest:

  • The capture mode is enforced. On a project set to Normal, the server discards console logs, failed requests, breadcrumbs, the technical record and non-device metadata even if a client sends them (an old extension build, a cached script, a hand-written request) — the setting is enforced, not just requested. Marked-element data is separately dropped unless the project enables element capture, a switch that is off by default and set only through the project API.
  • Lists are re-capped. Breadcrumbs are re-trimmed to the project’s configured count (clamped between 1 and 100, default 20); failed requests are re-capped to 20; console entries to 200. The client’s caps are never trusted.
  • Values are clamped. Every kept value is reduced to a bounded scalar: element fields to 1000 characters, list entries to 500, a console message to 2000. Only known keys per entry are retained, so an attacker-supplied key cannot bloat the row.
  • Geometry is allowlisted. A pin’s geometry keeps only the fields the annotator’s contract defines, which is what stopped an anonymous caller writing megabytes of JSON per report.

The AI triage features are off for every account until its plan includes AI and an admin switches consent on; the platform’s providers today are Groq and Google Gemini. When an account consents, the boundary is structural rather than a rule someone has to remember: the provider contract receives the report’s text (the comment, the console lines, the page URL) and has no path to the screenshot, the reporter’s email or the technical enrichment at all. The console lines are scrubbed again on the way. See Subprocessors.

Best-effort, not a guarantee

Secret detection is heuristic. It can over-mask (which the reporter sees in the review step) and it can miss a value; a miss is a defect to fix with a new pattern, not a reason to disable masking.

Cross-origin content

Redaction inherits the screenshot’s limits: cross-origin iframes can’t be inspected, so their fields are skipped rather than masked. Keep sensitive content on same-origin surfaces.

Redaction is off by default

A new project captures without field masking, without sensitive-selector masking and without the secret-pattern pass over captured text, until someone switches Auto-redact sensitive fields on. Only the query-parameter blanking is unconditional.

Review still applies

The reporter sees the already-masked screenshot before sending, next to a plain sentence naming what is being shared and a link to your privacy policy if you set one. Redaction is visible, not silent: it complements the review step rather than replacing it.