Is Your Session Replay Tool Leaking Sensitive Data? A 2026 PII Masking Checklist
Password fields get masked by default in most session replay tools, card numbers, health data, and sessions that keep recording after a user withdraws consent often don't. A practical 2026 checklist for engineers and privacy reviewers.
We build session replay at Pintelly, so we've spent a lot of time thinking about what masking actually needs to cover, and where it quietly doesn't. A user types a card number into a checkout form, then abandons it. A support agent pastes a patient's diagnosis into a free-text field on an internal tool. A visitor rejects your cookie banner mid-session. In each case, the question that matters is: does your session replay recording actually protect that moment, or does it just assume it does?
Most teams never ask this question at setup, because "records the DOM" sounds inherently safer than "records network requests." It isn't. Session replay tools rebuild what was visually on screen, and what's on screen routinely includes exactly the data you don't want in a third-party storage bucket. Default masking behavior also isn't standardized across vendors, one tool may mask every input field out of the box, another may mask only type="password", and a third may keep recording for a few seconds after a user opts out.
This is a working checklist, not a vendor pitch: what session replay actually captures, which fields typically fall through the cracks, how to verify a tool's consent-withdrawal behavior, and where masking stops being enough for PCI-DSS or HIPAA-adjacent data. Where we describe our own session replay module, every claim below is checked against its source and flagged if it isn't.
What Session Replay Actually Records
Session replay libraries, ours included, work by taking a full DOM snapshot when recording starts, then streaming incremental mutation, input, and scroll events after that. On playback, those events are replayed against the snapshot to reconstruct what the visitor saw. This is the same underlying technique used by most rrweb-based tools on the market.
The practical implication: anything rendered in the DOM is a recording candidate. That includes form fields, but also plain rendered text, an account page showing "Welcome back, Jordan Lee, [email protected]" is captured the same way a paragraph of marketing copy is, unless something explicitly excludes it. Two separate controls are needed to handle this, and conflating them is the most common masking mistake:
- Input masking hides the value typed into a form field. It does nothing for data that's already rendered as static or dynamic text elsewhere on the page.
- Consent-withdrawal behavior is a separate mechanism entirely. A tool can mask every input perfectly and still keep recording after a visitor opts out, if the recorder itself isn't torn down on that signal.
The checklist below treats these as two different problems, because verifying one tells you nothing about the other.
Why Default Masking Behavior Isn't Standardized
There's no single spec that session replay vendors follow for "default masking." Some mask every text input by default; others mask only password fields and expect you to configure a selector or CSS class for everything else, card numbers, national ID numbers, free-text health notes. If your team has used more than one session replay tool, assuming both behave the same way is the risk: a masking rule that was correct on vendor A can be silently wrong on vendor B with the exact same integration code.
This gap is also why the topic has renewed relevance in 2026. Website-tracking litigation under California's CIPA has grown substantially, public trackers put the case count in the thousands, concentrated in California but spreading to other states, and at least one 2026 suit names a session replay vendor directly rather than only the website operator. None of this means masking alone makes a deployment "compliant" (it doesn't, and no vendor should claim it does), but it's part of why "what does this tool record by default, and does it stop on request" is now a question security and privacy reviewers ask before an SDK is approved, not after an incident.
If you need the deeper legal analysis, CIPA theories, GDPR consent requirements, how courts have ruled on standing in 2025–2026, that's a separate, dedicated topic; this article stays on the technical masking and data-handling side.
The 2026 PII Masking Checklist
Use this to audit any session replay tool, including ours. Not every row applies to every product, a SaaS tool with no payment form doesn't need to worry about card-field masking, and one with no clinical text fields doesn't need the health-data row. Check only what actually exists in your product.
| Field / data type | Typical default risk | What to verify |
|---|---|---|
Password (type="password") | Usually masked by default across most rrweb-based tools | Confirm this is documented as a default, not an opt-in feature you have to enable |
| Card number / CVV | Often type="text" or type="tel", not auto-masked just because it looks sensitive | Add an explicit masking rule, or better, move payment collection into a hosted/tokenized third-party field outside the recorded page |
| Email / phone inputs | Varies by vendor, some mask all inputs, some mask password only | Fill the form in a staging session and open the actual recording to confirm |
| Free-text / health-related fields (textarea, notes) | Rarely covered by default masking | Define a selector- or class-based masking rule, or exclude the containing element from recording entirely |
| Rendered (displayed) text, names, emails, addresses shown on the page | Input masking does not cover this at all | Requires text-node masking or element-level exclusion, separate from form-input masking |
| Third-party payment iframe | Usually outside the parent page's DOM, so often naturally out of scope | Don't assume, verify in a real recording that the iframe's contents never appear |
| Console logs | A stray console.log(user) in application code can leak PII into the log stream, not the DOM | Restrict production log-level capture to error, and audit application code for logging full objects |
| Dynamically injected / lazy-loaded fields | Masking rules defined at page load may not reapply to content mounted later | Confirm the masking mechanism is selector/class-based and still applies after re-renders, not a one-time snapshot rule |
The goal isn't checking every box, it's identifying which rows apply to your product and verifying each one against an actual recording, not the vendor's marketing copy.
Does Recording Actually Stop When Consent Is Withdrawn?
This is the question masking checklists usually skip, and it matters as much as field-level masking. When a visitor rejects tracking, through your own consent banner or a tool's built-in one, three things need to be true:
- The recorder itself stops, not just the network call that would have sent the next chunk. A tool that keeps
rrweb.record()running in the background and merely suppresses uploads is still capturing data in memory. - Data buffered before the withdrawal is handled deliberately, not silently. Events collected while consent was still valid can reasonably be flushed and sent, but anything captured after the withdrawal should not be.
- The decision is read from the actual signal, not just a dashboard toggle. If your organization runs its own consent banner (OneTrust, Cookiebot, or a custom one) and calls the vendor's SDK programmatically, confirm the SDK listens to that call, not only to its own optional built-in banner.
How our session replay handles this, grounded in the SDK source: session replay sits in what the codebase calls the "sensitive tier" alongside cursor tracking, unlike anonymous page-view measurement, it never starts until an explicit granted = true signal is received; a denied or undecided state keeps it off. When window.Pintelly.setConsent(false) is called, or a visitor's prior denial is detected, our SDK's disableSessionReplay() runs synchronously: it flushes whatever was already buffered (data legitimately collected while consent was active), then tears down the rrweb recorder and clears session state. No new events are captured after that call returns. This is exercised directly by our consent-tiering test suite, which asserts that the sensitive tier stays gated behind an explicit grant and that consent withdrawal discards in-flight personal data. One deliberate exception: when the site owner calls window.Pintelly.identify(userId), that call is the site owner's own consent decision as controller, so a visitor-side refusal does not stop tracking for that visitor; only the site owner's setConsent(false) or reset() does.
Whatever tool you use, don't take "we support consent mode" at face value, reproduce this in a staging environment: start a recording, call the withdrawal method mid-session, and confirm in devtools that no further events fire.
PCI-DSS and HIPAA: What Masking Does and Doesn't Cover
Masking reduces the chance that regulated data lands in a session recording. It does not, by itself, make a session replay deployment PCI-DSS or HIPAA compliant, and no vendor's default settings should be read as a substitute for your own scoping and controls.
For PCI-DSS-adjacent data: card verification values (CVV/CVC) must never be stored after authorization, in any form, even masked or encrypted. If a CVV field is capable of appearing in a recording at all, that's a scope problem to solve architecturally, not a masking rule to tune. The safer pattern is to keep payment fields off the recorded page entirely, a hosted or tokenized third-party payment iframe, rather than relying on masking to catch every card-related input.
For HIPAA-adjacent data: patient names, diagnosis codes, and treatment notes are frequently a rendered text problem, not an input problem. If that kind of content is displayed on a page at all, input masking won't touch it, you need either full page-level exclusion for that view or element-level exclusion for the specific component rendering it.
Where we stand on this, without overstating it: we are not PCI-DSS certified and are not a HIPAA business associate offering by default. Our Terms of Service require that customers not collect passwords, payment-card data, health data, or other special-category data through the platform unless it's expressly supported and lawfully configured, the responsibility for keeping regulated data out of scope, or configuring the right exclusion, sits with the customer running the integration. Default masking is an architectural choice that lowers accidental-leak risk; it is not a compliance certification, and this article isn't claiming otherwise for any tool, including ours.
How Our Session Replay Handles Masking
To be specific rather than promotional, here's exactly what our SDK does, each claim tied to what's actually shipping in the source:
- All inputs are masked by default, not just passwords. Recording is initialized with
maskAllInputs: true, so the value of every input field, email, card number, free text, not onlytype="password", is masked from the start; raw form values are never written into the recording. - Rendered text can be masked separately. Any element tagged with the
fm-maskCSS class has its text content masked in the recording even if it isn't a form field, this is the mechanism for the "rendered text" row in the checklist above. - Full element exclusion is available via rrweb's standard
rr-blockclass. Our dashboard's own player code confirms this isn't overridden or renamed, tagging an element withrr-blockkeeps its entire subtree out of the recording, which is the right tool for a payment iframe container or a clinical-notes panel you want out of scope entirely. - Consent withdrawal stops recording synchronously, as described above, not "on the next page load," not "after the current chunk finishes."
- Retention is tiered, not a flat window. A recording that's never viewed is deleted 7 days after its last chunk; a viewed recording is kept for up to 30 days. A recording an authorized dashboard user explicitly saves is exempt from automatic deletion until a dedicated saved-item retention policy ships.
None of this is presented as a compliance certification, it's the specific architecture, so a reviewer can check it against their own requirements instead of taking "privacy-first" as a marketing claim.
How to Test Your Masking Rules
The checklist above is only useful if you actually run it against a real recording. In a staging or test environment:
- Fill in forms with realistic-but-fake data, a dummy card number, a fake email, a placeholder diagnosis note if that field exists in your product.
- Open the resulting recording and check each field individually against the table above.
- If a field that should be masked is visible, that's a configuration gap, fix it before it ships to production, not after a real user's data appears in a recording.
- Repeat this whenever a new form or page section is added. Masking coverage tends to go stale the same way test coverage does, a field added six months after the original audit is easy to miss.
- Separately, verify the consent-withdrawal behavior described above by triggering it mid-session and confirming no further events are captured.
Try It on Your Own Forms
The fastest way to trust, or distrust, a session replay tool's masking claims is to test them against your own product, not read about them. our session replay ships with input masking on by default and stops recording synchronously the moment consent is withdrawn; run the test steps above against a staging deployment to see exactly what does and doesn't appear in a recording before you decide it's safe for production traffic.
FAQ
Does session replay record password fields?+
In most rrweb-based tools, including ours, password fields are masked by default, the recording shows a masked placeholder, not the typed value. Still verify in your vendor's documentation whether this is a true default or a setting you need to enable.
Is masking input fields enough, or do I also need to mask visible page text?+
Input masking alone isn't enough. It only covers values typed into form fields. Names, emails, or addresses shown as rendered text elsewhere on the page need a separate text-masking or element-exclusion rule.
If a user rejects consent, does recording stop immediately?+
It depends on the tool, some only block new sessions while an in-progress recording continues in the background. At Pintelly, calling the consent-withdrawal method stops the recorder synchronously: buffered data collected before withdrawal is sent, but nothing is captured after.
Does default PII masking make a session replay tool PCI-DSS or HIPAA compliant?+
No. Masking reduces the risk of regulated data appearing in a recording, but scoping, data minimization, and contractual obligations remain the customer's responsibility. For card or health data, the safer approach is keeping that data out of the recorded DOM entirely, not just masking it.
How long are session replay recordings kept?+
At Pintelly, a recording that's never viewed is deleted after 7 days; a viewed recording is kept for up to 30 days. Recordings explicitly saved in the dashboard are exempt from automatic deletion.

