What a session replay script records inside your profile
Most people who look into anti-detect browsers start with fingerprinting: canvas hashes, WebGL renderer strings, font lists, timezone mismatches. That’s the static side of detection, a single snapshot taken when a page loads. Session replay tracking is a different animal. It doesn’t take a snapshot. It records a movie, and the camera keeps rolling for as long as you’re on the page.
If you’re running multiple profiles for multi-accounting, it’s worth understanding what that movie actually contains, because it’s not covered by anything a canvas spoof or a WebGL override touches.
What a replay script actually captures
A session replay tool works by hooking into the DOM as soon as it loads. Tools in this category (FullStory, Hotjar, LogRocket, Smartlook, and similar) generally use a MutationObserver to watch every change to the page structure, plus a set of event listeners on mousemove, click, scroll, keydown, keyup, input, and focus. Every one of those events gets a timestamp and gets queued for upload.
The result is a reconstructable timeline, not a single data point:
- Cursor path across the screen, including the little corrections and hesitations before a click.
- Scroll speed and scroll position over time.
- Which fields you focused on, in what order, and how long you dwelled in each one before typing.
- Keystroke timing on form inputs (some tools mask the actual characters typed into password or payment fields, but they still record that typing happened and when).
- Viewport size, device pixel ratio, and any resize events.
- Console errors and, on some platforms, network request timing.
On playback, a trust and safety analyst can literally watch a recreated video of what you did, frame by frame, built entirely from these event logs. That’s the point of the tool commercially: UX teams use it to see where users get stuck. Fraud and account-security teams use the exact same data for a different purpose, reviewing flagged sessions to see whether the behavior looks like a person or looks scripted.
How this is different from a fingerprint script
A fingerprinting script asks a bunch of static questions once: what does navigator.userAgent say, what does the canvas render as, what fonts are installed, what’s in navigator.plugins. It runs, hashes the answers, and is done in milliseconds. That’s what anti-detect browsers like Multilogin, GoLogin, Kameleo, AdsPower, and Dolphin Anty are built to intercept and rewrite, because those are discrete API calls they can hook and return spoofed values for.
Session replay isn’t asking questions, it’s watching input devices. There’s no single API call to intercept, because the “signal” is the aggregate pattern of hundreds of real mouse and keyboard events over minutes. If you’re a real person moving a real mouse, the replay just faithfully records your real mouse. Spoofing navigator.hardwareConcurrency does nothing to change the shape of your cursor path.
That’s a meaningful distinction for anyone evaluating what an anti-detect browser can and can’t do for them. These tools are built to make the static fingerprint surface look like a different, consistent device each time. They are not built to generate human-plausible mouse movement or typing cadence, and none of the major vendors market it that way. Behavioral realism is a separate problem from fingerprint spoofing, and if a profile’s browsing is driven by an automation script with linear cursor jumps or uniform keystroke timing, that shows up in a replay recording as clearly as it would to a human watching over your shoulder.
Where the two systems actually meet
The interesting overlap is where fingerprint spoofing leaves a footprint the replay tool can pick up as a side effect. A few concrete examples of how that happens:
Injected overrides change function behavior in ways JavaScript can detect. If a page calls HTMLCanvasElement.prototype.toDataURL.toString() and gets back something other than "function toDataURL() { [native code] }", that’s a signal the function has been patched. A site running both a fingerprint SDK and a replay tool can log that anomaly straight into the session record.
Timing differences are another leak. A native canvas render and a spoofed one that has to compute and return a modified pixel buffer don’t always take the same number of milliseconds. Replay tools that log performance timing entries or network waterfall data can end up capturing that difference, even though it wasn’t the point of the recording.
Console errors are a quieter one. Some spoofing methods throw or log errors under specific conditions, like when a script probes for automation flags or when a browser extension used to inject overrides collides with page code. Replay tools frequently capture the console alongside the DOM, so any of that noise ends up sitting in the recording next to your click stream.
None of this means every anti-detect browser leaks in this way, and it’s not something that turns up unless a specific site is running both a fingerprint SDK and a replay tool and someone on the other end is actually reviewing the recording. But it’s worth knowing that “passed the fingerprint check” and “the session looked clean on replay” are two different bars, and a tool can clear the first without automatically clearing the second.
Profiles are the actual unit being tracked
Here’s the part that matters most for anyone running several accounts. Session replay tools don’t record a session in isolation, they tie it to a persistent visitor identifier stored in a cookie or in local storage. That identifier survives across sessions on the same profile. So the “movie” isn’t just one browsing session, it’s a running record attached to that specific profile over its whole lifetime.
This is exactly why profile hygiene matters more than fingerprint uniqueness alone. If two of your profiles share a browsing pattern (the same order you check pages in, the same pause length before submitting a form, the same scroll rhythm), a team reviewing replays side by side doesn’t need matching fingerprints to notice the two “different users” behave identically. Anti-detect browsers handle the fingerprint layer. They don’t do anything about the fact that it’s still you, with your own habits, sitting behind every one of those profiles.
What this actually means in practice
None of this is a reason to panic, and it’s not a reason to believe any browser makes this problem go away either. Session replay tracking exists on a lot of major platforms specifically because static fingerprinting has known blind spots, and behavioral data fills a lot of those gaps. No anti-detect browser on the market is undetectable, and none of them are risk free, whatever the marketing pages next to them say. What they actually do is give you a clean, isolated, consistent fingerprint per profile so you’re not the obvious case of ten accounts sharing one canvas hash. What happens inside that profile, how you move, how you type, how consistently you behave across ten different browser windows, is still on you.
If you’re serious about running multiple accounts, understand both halves of the detection stack, not just the fingerprint half. Know what a replay script logs, know that it’s a different tracking system than the one your anti-detect browser is built to fool, and don’t assume a clean fingerprint report means a clean session recording.
If this kind of breakdown is useful, there’s more like it, along with hands-on testing of specific anti-detect browsers, over on the home page.
Get new guides and videos first — join the Telegram channel.