← back to blog

Crash Recovery and the Tabs That Link Two Profiles

When a crash tells on you

Nobody thinks about crash recovery until it does something they didn’t ask for. You force-quit a browser window because it froze, you reopen it a minute later, and a little bar asks if you want to restore your last session. Most of the time that’s a convenience. In an anti-detect setup running several personas, it can be the moment two profiles that were never supposed to touch each other end up in the same window, or the moment a crash report leaves your machine carrying an identifier that’s identical across profiles you paid to keep separate.

This isn’t a platform-side detection trick. Meta or Google or TikTok can’t see your local crash dumps. What they can eventually see, indirectly, is the downstream effect: two accounts that behave, log in, or share device signals in a way that only makes sense if the underlying browser state was never as separate as the profile switcher implied. The actual leak happens earlier, on your disk, in files most people running these tools have never opened.

This piece is about three separate mechanisms that all get lumped under “crash recovery” but behave differently: session and tab restore, the shared identity file that Chromium keeps at the root of a user data directory, and the OS-level crash reporting that happens outside the browser entirely. Each one has a different blast radius, and each one has a different fix. None of them are exotic. They’re just easy to miss because “restore my tabs” looks like a UX feature, not a data leak, right up until it shows you the wrong tabs.

The goal here is to show you exactly which files carry state across a crash, which of those files anti-detect tools are supposed to isolate per profile, and how to check in about twenty minutes whether the tool you’re actually using does that or just looks like it does.

How Chromium actually remembers your tabs

Every Chromium-based browser, whether it’s stock Chrome or the forked build inside an anti-detect tool, keeps track of open tabs and windows through a pair of mechanisms living inside each profile folder. The first is the Sessions directory, which holds SNSS-format files recording window layout, tab order, and navigation history for the current and previous browsing session. The second is Session Storage, a separate on-disk store tied to each origin that holds the sessionStorage API data web pages write, which is what lets a site remember form state or a shopping cart across a reload.

When Chromium starts up after an unclean shutdown, whether that’s a real crash, a forced kill, or the OS pulling the plug, it checks the Sessions folder for a session file that wasn’t closed cleanly and offers to restore it. That’s the infobar you’ve seen: “Chrome didn’t shut down correctly. Restore pages?” Some builds skip the prompt entirely and just reopen the last session automatically if the “continue where you left off” startup setting is enabled, which is the default in a lot of forked antidetect builds because it matches what most users expect from a normal browser.

Under a properly isolated setup, this is all scoped to a single profile folder. Persona A’s Sessions folder only ever contains persona A’s tabs. The mechanism itself isn’t the vulnerability. The vulnerability shows up when the folder boundary that’s supposed to contain this data gets crossed, either by the tool’s own architecture or by how an operator manages profiles day to day, both of which the next two sections cover.

The Local State file: one identity file for every profile

Here’s the part almost nobody checks. At the root of every Chromium user data directory sits a file called Local State. It’s JSON, it’s small, and it’s not part of any individual profile folder, it lives one level above them. Inside it, under a key like user_experience_metrics, Chromium stores a client ID: a randomly generated identifier used to tag every piece of telemetry, every crash report, and every UMA metrics ping that installation ever sends.

The important detail is what “installation” means here. If you’ve ever used Chrome’s built-in multi-profile feature, the one where you click your avatar and switch between “Work” and “Personal,” those are separate folders, Default, Profile 1, Profile 2, all living under one shared user data directory root, all sharing one Local State file, and therefore all sharing one client ID. Google’s own telemetry can’t tell “Work” and “Personal” apart at the client-ID level, because there’s only one ID for the whole install.

This matters enormously for anti-detect tools because it’s exactly the architecture shortcut that’s cheapest to implement and easiest to get wrong. A tool that creates personas as subfolders under one shared root, the way Chrome’s native profile switcher does, inherits this exact problem. Every persona under that root shares one Local State file, one metrics client ID, and one Crashpad database, which I’ll get to next. Any crash report or telemetry ping fired from persona A carries the same client ID as one fired from persona B, because as far as the underlying Chromium code is concerned, they’re not different installs, they’re just different chairs at the same desk.

The fix isn’t complicated, but it has to happen at the architecture level, not the settings level. A profile needs its own user data directory root, its own Local State file sitting above its own Sessions and Crashpad folders, not a subfolder nested inside a shared root. That distinction, root versus subfolder, is the whole ballgame, and it’s not something you can tell from the UI. You have to go look at the file paths.

Why separate profile folders is the wrong bar

“Each profile gets its own folder” is the line most anti-detect tools lead with, and it’s true in a narrow, technically accurate way that doesn’t actually answer the question that matters. The question isn’t whether profiles have separate folders. Nearly everything does, including stock Chrome’s native multi-profile feature, which as covered above still shares a Local State file and a Crashpad client ID across all of them. The question is where the folder boundary sits: is it a subfolder under one shared user-data-dir root, or is the entire user-data-dir itself unique per persona, with nothing shared above it.

This distinction rarely shows up in marketing copy because it sounds like the same thing to anyone who hasn’t opened a file browser and compared paths. “Isolated profiles” gets used for both architectures. One of them isolates cookies, local storage, and cache, which stops the obvious stuff, session hijacking between tabs, cross-tab cookie leakage. The other additionally isolates the metrics client ID, the crash reporter database, and the session restore boundary, which stops the quieter stuff this article is actually about.

You can’t tell which one you’ve got by reading a features page. You have to open the folder the tool actually writes to on disk (most expose this in settings, or you can watch it with Process Explorer while the browser is running) and check whether each persona’s path is a fully distinct root, something like .../profiles/persona-a/ and .../profiles/persona-b/ as siblings each containing their own Local State, versus .../profiles/root/Profile 1/ and .../profiles/root/Profile 2/ sharing a parent that holds one Local State for both.

This isn’t a claim that any specific vendor gets this right or wrong across the board, and it can change between versions. It’s a claim about what the file layout tells you when you check it yourself, which is the only reliable way to know. Treat “separate profiles” as a marketing phrase until you’ve confirmed which architecture it’s describing on your own disk.

Crashpad and where your hardware info actually goes

Crash reporting in Chromium runs through a component called Crashpad, a separate handler process that watches the browser and, when it crashes, collects a minidump and, if the user hasn’t opted out, uploads it to Google’s crash collection endpoints. The Crashpad database lives in its own folder, typically named Crashpad, inside the user data directory, and it maintains a settings file with its own client ID, generated independently of but functionally parallel to the Local State metrics ID.

What actually goes into a crash report matters here. A minidump can include process memory at the time of crash, loaded module lists, OS version and build number, GPU vendor and driver version, and depending on configuration, the command line the process was launched with. That last one is worth sitting with: if the antidetect tool launches each profile with --user-data-dir=<path> as a command line flag, and the crash dump captures the command line, then the report itself can contain the literal folder path used for that persona. Two crash reports from the same physical machine referencing different persona folder names, sitting on the same crash collection endpoint, tagged with the same client ID if the tool shares Local State, is a correlation signal handed directly to whoever operates that endpoint.

For a stock Chrome install, that’s Google, and Google isn’t in the business of cross-referencing your anti-detect personas. But a forked Chromium build used by an anti-detect vendor may or may not have stripped or redirected this reporting, and if it hasn’t, you’re trusting a third party’s crash infrastructure with information about your setup that you never explicitly agreed to send anywhere. Check chrome://settings for a toggle usually labeled something like “help improve this browser” or “send crash reports,” and check chrome://crashes to see what’s actually been logged and whether it shows as uploaded. Both are worth five minutes the first time you set up a new tool, not something to assume based on what the vendor’s landing page says about privacy.

The clone shortcut that breaks isolation

Setting up a new persona from scratch, configuring the fingerprint parameters, timezone, screen resolution, fonts, canvas noise, takes time. So a common shortcut, both inside some tools’ own “duplicate profile” buttons and among operators managing things manually, is to clone an existing, already-configured profile folder and just swap the proxy and a couple of fingerprint fields on the copy. It’s faster, and for the fingerprint parameters alone it usually works fine.

The problem is that a raw folder copy doesn’t stop at the fingerprint config. It also copies the Sessions folder, the Session Storage data, the Local State file if it exists at that level, and the Crashpad database, meaning the client ID, metrics ID, and open-tab state of the source profile all travel with the clone. If the tool’s own “duplicate” feature does this under the hood without explicitly purging those directories, you get the same result even without touching a file manager yourself.

The failure mode isn’t subtle once it happens, but it’s easy to miss until it does. The cloned profile, on first launch, may still be holding the source profile’s last session file. If that launch happens to be unclean, or if the tool’s default startup behavior is “continue where you left off” rather than “open a blank page,” the clone can prompt to restore, or silently restore, tabs that belong to the profile it was copied from. If those tabs include a logged-in dashboard, an open DM thread, or an account settings page from persona A, they’re now sitting inside persona B’s window.

This is entirely an operator-side and tooling-side issue, not a flaw in Chromium. The fix is procedural: never clone a profile by copying its folder wholesale unless you also delete Sessions, Session Storage, and Crashpad from the copy before first launch, and confirm the tool’s own duplicate function does the same before trusting it.

A worked example of tab bleed

Walk through what actually happens on disk, because the abstract version undersells how mundane the mistake is. Say you’ve spent twenty minutes getting persona A’s fingerprint dialed in, correct timezone against its proxy’s geolocation, matching font list, plausible screen resolution for the claimed OS and hardware. You open the account you’re managing under persona A, leave a couple of tabs open, the account dashboard and a settings page, and close the tool for the day without cleanly logging everything out first.

The next morning you need a second account for the same platform. Rather than reconfigure a fingerprint from zero, you copy persona A’s entire profile folder to a new directory, rename it, and open the tool’s settings to change the proxy and nudge the canvas fingerprint slightly. You launch it. Because the copy still contains persona A’s Sessions folder with an SNSS file describing two open tabs, and because the tool’s default startup setting is “restore previous session,” it opens directly into those two tabs: the dashboard and settings page for persona A’s account, now rendering inside a browser window configured with persona B’s proxy and persona B’s fingerprint.

If you don’t notice and start working, you might load persona A’s dashboard through persona B’s proxy IP, which is one part of the leak, an account associated with one IP suddenly making requests from a different one it’s never used. Or you might, without thinking, navigate from that restored tab straight into logging in to the second account, meaning both accounts have now, at some point, touched the same session storage, the same browser process, and possibly the same referrer chain, all before you’ve done any actual work under persona B.

None of this requires a platform to be running some sophisticated cross-profile detection. It requires exactly one unclean shutdown and one folder copy that copied Sessions along with everything else. It’s also completely preventable, which is the point: check the restore prompt on any cloned profile’s first launch before doing anything else in it.

What lives on the OS level, outside any browser

Everything so far has been inside the browser’s own user data directory. There’s a separate layer sitting underneath all of it: the operating system’s own crash handling, which runs regardless of what the browser itself does with Crashpad.

On Windows, this is Windows Error Reporting, WER. When any process crashes, WER can generate a report stored under %LOCALAPPDATA%\Microsoft\Windows\WER\ReportArchive or dump files under %LOCALAPPDATA%\CrashDumps, tagged with the crashing executable’s name and, depending on configuration, its command line arguments. Critically, this happens at the level of the Windows user account, not the browser profile. If you’re running five personas’ worth of browser windows from one Windows login, launched from five different --user-data-dir paths, and any of them crashes hard enough to trigger WER rather than being caught cleanly by Crashpad first, the resulting dump sits in one shared folder that has nothing to do with which persona triggered it.

This matters in two specific situations. First, if the machine is ever examined forensically, seized, imaged, or inspected by malware or an EDR agent that has file system access, that shared CrashDumps folder is a straightforward list of every browser process that’s crashed recently, with folder paths in the metadata potentially naming every persona that’s been run from that machine. Second, and more mundane, if you’re running personas from a shared VPS or RDP session with teammates, WER doesn’t know or care whose persona crashed, everyone with access to that Windows account can see the accumulated dump history for all of them.

macOS has an equivalent in its own crash reporter, writing to ~/Library/Logs/DiagnosticReports, same shared-per-user-account exposure. Neither of these is something a browser-level fix addresses, because they operate below the browser entirely. It’s worth knowing this layer exists even if there’s not much day-to-day action to take beyond being aware of who else has access to the machine.

What this technique can and can’t tell a platform

Worth being precise about the actual threat model here, because it’s easy to conflate “this data exists on disk” with “a platform can see it,” and those are very different claims. Meta, Google, TikTok, none of them have access to your Local State file, your Crashpad database, or your Windows Error Reporting archive. Crash recovery and telemetry leakage is not a remote fingerprinting vector in the way canvas rendering or WebGL parameters are, where the platform’s own JavaScript can query the value directly from a page you loaded.

What crash and session state actually threatens is different and, in some ways, more consequential precisely because it’s not visible to any automated detection system. It’s a risk to you, the operator, in three forms. First, direct exposure if your device is ever examined by someone else, whether that’s a forensic investigator, a stolen laptop, or malware with file system access. Second, telemetry exposure to whatever party operates the crash collection endpoint your forked browser is still pointed at, which for most Chromium forks defaults to Google unless explicitly redirected or disabled. Third, and by far the most common in practice, self-inflicted operational mixing, where tab bleed from a badly cloned profile causes you to accidentally cross-contaminate two accounts’ network paths or session state yourself, which the platform absolutely can detect, because it sees the resulting behavior: two accounts sharing an IP, a login pattern, or a session token they shouldn’t share.

That distinction matters for where you spend your effort. There’s no setting that stops a platform from noticing correlated behavior after the fact. There is a set of concrete file-level habits that stop the behavior from becoming correlated in the first place. The rest of this piece is about the second kind.

Real isolation versus folder isolation

Three broad architectures handle profile isolation with meaningfully different guarantees, and it’s worth understanding the tradeoffs rather than assuming more isolation is automatically the right call for every use case.

Folder-level isolation, separate user-data-dir roots as described above, is the cheapest and fastest, and it’s sufficient for the Local State and Crashpad problems this article covers, as long as it’s implemented correctly with full root separation rather than shared-parent subfolders. What it doesn’t touch is anything below the browser process: OS-level crash reporting, machine GUID, disk serial, install timestamps, all the things that live at the host level regardless of how many browser profiles run on top of it. If two personas run on the same physical machine, they share that host layer no matter how well the browser-level folders are separated.

Container-level isolation, running each profile inside its own lightweight container with a separate filesystem namespace, closes some of that gap. WER-equivalent crash handling can be scoped per container rather than per host user account, and some host-level identifiers can be virtualized. It still shares the underlying kernel and, depending on configuration, can still leak host-level timing or resource signals between containers on the same physical box.

VM-per-profile is the heaviest option, giving each persona its own full OS instance, its own WER archive, its own machine GUID, its own everything. It’s also the most expensive in both compute cost and setup time, and for most multi-accounting work it’s overkill relative to the actual risk being managed, which for most operators is the browser-level leaks, not host-level forensic exposure.

None of these eliminates risk entirely, and none of them should be described as making an account unbannable or a profile undetectable, because the platform-side risk this article isn’t primarily about, canvas and WebGL and behavioral fingerprinting, operates independently of which of these three architectures you pick.

An audit you can run in twenty minutes

This is the actual test, not a features page, run against whatever tool you’re currently using.

Launch persona A, open two or three distinct tabs to sites you’d recognize at a glance, then force-kill the browser process directly, not a clean close, use Task Manager or taskkill on Windows, or kill -9 on the process on macOS or Linux, to simulate an actual crash rather than a graceful shutdown.

Reopen persona A. Confirm the restore prompt, if one appears, offers only persona A’s tabs. Then open a second, unrelated persona, B, in the same tool and confirm it does not also offer to restore persona A’s tabs, and that its own tab state is untouched by what happened to A.

Find the actual folder path each persona writes to on disk, most tools expose this in a settings or profile detail panel, or you can watch it with Process Explorer’s command-line column while both are running. Confirm the two paths are sibling roots, not a shared parent with subfolders.

Open the Local State file, plain JSON, readable in any text editor, from each persona’s root folder if isolation is done correctly, or from the shared root if it isn’t. Compare the client_id value under user_experience_metrics between the two. If they match, the two personas share a metrics identity regardless of how separate their tab and cookie data looks.

Check for a Crashpad folder under each persona’s root and confirm each has its own settings.dat. Check chrome://settings for the crash reporting toggle and chrome://crashes for upload history in each.

On Windows, glance at %LOCALAPPDATA%\Microsoft\Windows\WER\ReportArchive to see what’s accumulated there and whether entries reference browser processes with identifiable command-line paths.

Twenty minutes, no special tooling beyond what’s already on the machine, and it tells you more than any comparison chart will.

Turning off what you can turn off

A handful of settings and habits close most of what this article covers, none of them requiring you to switch tools.

Turn off automatic crash and usage reporting in each profile if the browser exposes the toggle, usually under a privacy settings page, sometimes labeled “help improve” or similarly softened language. If the tool doesn’t expose a toggle at all, that’s itself worth noting, since it means you can’t confirm what’s being sent or opted out of it through the UI.

If you’re already routing each persona through its own proxy, and most multi-accounting setups are, you can extend that same per-profile egress control to block known telemetry endpoints at the proxy or firewall layer, the usual Chromium crash and metrics collection domains, without touching the browser’s own settings at all. This is a clean fix because it works regardless of whether the vendor’s fork respects its own opt-out toggle correctly.

Turn off “continue where you left off” or equivalent session restore behavior entirely for personas where you don’t actually need cross-session tab persistence. Most multi-accounting work doesn’t need it, you’re not using these browsers for long research sessions, and removing the setting removes the entire tab-bleed failure mode rather than just mitigating it.

Stop cloning profiles by raw folder copy. If a tool’s built-in duplicate function doesn’t explicitly document that it purges Sessions, Session Storage, and Crashpad from the copy, treat it as if it doesn’t, and manually clear those three directories before first launch of any cloned profile.

None of these are exotic changes. They’re closer to basic hygiene, and the reason they’re worth stating explicitly is that they’re invisible until the first time they matter, at which point the damage is already in a crash report or a restored tab.

Where this gets worse: shared hosts and shared machines

Everything covered so far assumes one operator managing personas from a device they fully control. A lot of real operations don’t look like that. Teams running multiple personas from a shared VPS or RDP session, or a physical machine passed between several people managing different accounts, add a layer this article’s fixes don’t fully reach.

Windows Error Reporting, as covered earlier, scopes to the Windows user account, not the browser profile. If a team shares one RDP login across several operators each running their own antidetect personas, WER’s crash archive accumulates entries for all of them in one place, visible to anyone else with access to that account, including whoever administers the VPS at the hosting level. Browser-level Local State and Crashpad isolation, even done correctly, doesn’t touch this, because it’s a Windows-account-level concern sitting below any individual browser install.

The practical fix, where it’s worth the cost, is separate Windows user accounts per operator on a shared box at minimum, since that scopes WER’s archive per account rather than pooling it, or separate VMs per operator where the operation justifies the overhead. Where it isn’t worth the cost, the realistic move is just knowing the exposure exists and factoring it into who gets access to that shared machine, rather than assuming browser-level profile separation covers everything happening on it.

There’s a loose parallel in cloud-phone farm setups, where cloning a device profile to spin up a new persona carries the same class of risk, app data, cached session tokens, and local notification state can survive a clone the same way Sessions folders do on desktop. The specifics differ by platform, but the underlying mistake, copying more state than you meant to, is the same one.

What to change Monday

Run the twenty-minute audit above against whatever anti-detect browser you’re currently using, once, and write down what you find for both the Local State comparison and the folder architecture. It takes less time than reading this article did.

Stop cloning profiles by raw folder copy without clearing Sessions, Session Storage, and Crashpad first, whether you’re doing it manually or trusting a “duplicate profile” button you haven’t verified.

Turn off session restore on personas that don’t need it, and turn off crash and usage reporting wherever the setting is exposed.

If any personas run from a shared VPS or shared physical machine, check who else has access to that machine’s crash archive, and treat that as a separate exposure from anything browser-level isolation fixes.

None of this makes any profile undetectable or any account unbannable, and nothing here changes the canvas, WebGL, or behavioral signals a platform can query directly from a loaded page. It closes a different door: the one where two personas that were supposed to be separate end up sharing an identity because of a crash, a clone, or a shutdown that wasn’t as clean as it looked.

If you want more of this kind of hands-on, mechanism-level look at how anti-detect tools actually behave rather than what their landing pages claim, that’s the whole focus of the channel and the rest of the site here.

Get new guides and videos first — join the Telegram channel.

need infra for this today?