Skip to content
Sign inRequest access

Capture context & PII redaction

Context is what turns “the thing near the top is broken” into “this exact element is broken, and here’s the path that led there.” Most of that context comes with the project’s capture mode: a Technical project attaches the click and route trail, failed requests and the console; a Normal project attaches none of them. Element pinpointing has its own switch, and redaction runs in the browser, so what it covers is scrubbed before it ever reaches uMarker.

Element pinpointing

The CSS selector, DOM path, position and tag/role of the element the reporter pinned, so a developer jumps straight to the component at fault.

Reproduction breadcrumbs

The last N actions (clicks, inputs, route changes) in order and timestamped, so a triager can replay the path to the bug. Technical mode only.

Failed requests

The method, URL and status of network calls that errored during the session. Technical mode only, on both the snippet and the extension.

PII redaction

Typed values masked in the screenshot, and secret-shaped strings scrubbed from text, before the report leaves the browser.

Redaction and your always-sensitive selector list are on Widget → Setup, in the Privacy card, beside the capture-mode card. The pinpointing switch and the breadcrumb count have no field on that screen, or anywhere else in the product, and are set over the dashboard API only. None of the four is gated by plan, and both capture modes are on every plan.

The reporter’s Inspect tool already knows which element they pointed at: when they hover, the widget resolves the deepest element under the cursor, draws its box model, and records that element’s own CSS selector into the pin. When pinpointing is on, the report resolves that selector back to the live element and attaches:

  • selector: a compact CSS selector. It prefers a stable #id; otherwise it builds a tag.class:nth-of-type(n) path (up to five levels), skipping class names that look generated or hashed — a css-, sc-, jsx- or emotion- prefix, anything over 30 characters, or three digits in a row. It’s a heuristic, not a guarantee: a short opaque hash like a1b2c3d4 passes every one of those tests and will be used.
  • dom_path: a deeper structural path (up to twelve levels) for context.
  • position: the element’s bounding box as x, y, w, h.
  • tag and role: the tag name and ARIA role.
  • confidence: high when the element has a stable id, low when the path had to fall back to positional :nth-of-type or lacked a stable class, medium otherwise.

Resolution is best-effort and never throws: a pin over an unidentifiable region records empty element fields with low confidence, and submission still succeeds. On the report page the pin is drawn over the screenshot as the element’s own box, with an orange band and a side label when the reporter commented on a margin instead. The selector itself is printed nowhere: not on that page, and not in what Copy report as text copies. That button’s Element: line is built from this enrichment block, so it appears only on a project that has pinpointing on — which today means a project configured over the API. dom_path and the pin’s own stored selector are returned by the API and displayed by no screen at all.

A report filed while the project is in Technical mode carries an ordered, timestamped trail of the last N actions before the capture. A Normal report has none, and in Normal mode the page does not record the trail at all:

Type What’s recorded
click A stable selector for the clicked element, plus a curated label (its aria-label or title).
input The field’s identifier: its name, id, aria-label, or placeholder.
route The new path on navigation, with the query string and fragment stripped.

Each entry is stamped HH:MM:SS. The widget keeps a rolling buffer and attaches the most recent N (the project’s breadcrumb count: default 20, up to 100); older actions are dropped so the payload stays bounded. The server re-caps and re-cleans the list; it never takes the client’s count on trust.

The widget quietly wraps fetch and XMLHttpRequest and records calls that fail, and both draw the line in the same place: a network error (a fetch that rejects, an XMLHttpRequest with status 0) or a status of 400 and above. A 304 you handle yourself, or an opaque no-cors beacon that succeeded, is not a failure and is not recorded. Each entry is just the method, URL and status; request and response bodies are never captured.

Failed requests, like console logs, belong to Technical mode: a Technical report stores the 20 most recent, and a Normal report has none, because in Normal mode the widget does not wrap fetch or XMLHttpRequest in the first place. The browser extension runs the same engine and records the same structured list. A Technical report also carries the full request log (every request the page made, with type, duration and size, failed and slow ones flagged); this list is the short, failures-only view of it.

Query parameters whose name looks sensitive (token, key, secret, password, passwd, pwd, auth, session, sid, sig, signature, otp, code, email, phone and the camelCase spellings of them) are replaced with [redacted] at capture time, so the raw value never enters the buffer that is sent — that one happens whether or not redaction is switched on. With redaction on, the whole URL is scrubbed for secret shapes as well before sending.

Redaction is the trust boundary that makes the widget safe to deploy on a real site. When it’s on it works in two layers, both in the visitor’s own browser — nothing is shipped raw for the server to clean up afterwards.

Those two layers cover the screenshot, the console logs, the failed-request URLs and the breadcrumbs. The page URL the visitor was on and the referrer are not part of them; they get the one rule that is always on, the same as the failed-request list: a query-string value whose name suggests a secret (token, session, email…) is blanked in the browser, and the rest of the address is kept. A secret under an innocent-looking name, or in the path itself, still reaches the report — keep that in mind on pages whose own URL carries one.

Just before each picture is taken — one for every screen the visitor marks, whether the browser’s own tab capture or the widget’s own drawing of the page — the widget masks value-bearing fields in the live DOM, then restores them as soon as that picture is taken, so your page is never left showing masked values:

  • Input and textarea values are replaced with bullet characters. Checkboxes, radios, buttons, submit buttons, ranges, color pickers and hidden inputs are skipped, since they hold no free text — and so are file inputs, which a browser refuses to overwrite, so the name of a file the visitor picked can appear in the screenshot.
  • contenteditable regions have their text masked, since their value lives in the text content, not a value attribute.
  • Always-sensitive selectors you list have their field value masked if they have one, and their text masked otherwise.
  • Same-origin iframes are masked too; cross-origin frames are skipped, because they can’t be read.

Console logs, failed-request URLs, and breadcrumb labels and URLs are passed through a redactor that replaces secret-shaped substrings with [redacted]. It targets:

  • Labelled keys: a sk, pk, api, key, token, bearer or secret label followed by its value. The separator may be a space, an underscore, a hyphen or an =, which is what catches ?token=abc123… in a query string, the one place a label and its secret sit right next to each other.
  • Long opaque tokens: runs of 32 or more token characters.
  • Card-shaped numbers: 13–16 digit groups.
  • Email addresses, and phone numbers written internationally (+966…, 00966…) or as a Saudi mobile (05…). Bare digit runs are left alone: a console is full of timestamps and ids.

The redactor deliberately errs toward over-masking. Because the reporter sees the capture before sending, over-masking is visible rather than silent. This is a best-effort safeguard (automatic input masking plus secret-shape scrubbing), not a full DLP engine; a missed value is a defect to fix, not a reason to turn masking off.

Setting Effect Default Where you set it
Capture mode Normal or Technical. Technical adds breadcrumbs, failed requests, the console and the rest of the technical record. Normal (new projects) Widget → Setup
Element pinpointing Attaches the pinned element’s selector, DOM path, position, tag/role, confidence. off API only
PII redaction Masks typed values in the screenshot and scrubs secret shapes from text. off Widget → Setup
Breadcrumb count How many recent actions a Technical report keeps (1–100). 20 API only
Sensitive selectors Elements always masked in the screenshot (one per row, up to 50). none Widget → Setup

The server enforces these on ingest, so a client can never over-send. For a Normal project it drops the breadcrumbs, failed requests, console and technical record, and keeps only the device metadata, even when an old extension build, a cached copy of the widget or a hand-written request sends them. If pinpointing is off the element block is dropped even when a client sends it. In Technical mode every list is re-capped (breadcrumbs to the project’s count, failed requests to 20) and every value clamped to a bounded length.