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.
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:
/\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:
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.
Render. The screenshot is produced from the now-masked DOM, so the typed values are never in
the image bytes.
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.
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.
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.
[data-private]: an attribute you add to sensitive regions
In the project’s widget settings, in the Privacy (PII redaction) section, alongside the
Auto-redact sensitive fields toggle and the privacy-notice link.
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.
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.